// Generated from C.g4 by ANTLR 4.5
// jshint ignore: start
var antlr4 = require('antlr4/index');
var CListener = require('./CListener').CListener;
var grammarFileName = "C.g4";

var serializedATN = ["\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd",
    "\3r\u0af4\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4",
    "\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t",
    "\20\4\21\t\21\4\22\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27",
    "\t\27\4\30\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4",
    "\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t",
    "\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t",
    "\61\4\62\t\62\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t",
    "8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC",
    "\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4",
    "O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z",
    "\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4",
    "e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\tk\4l\tl\4m\tm\4n\tn\4o\to\4p",
    "\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4w\tw\4x\tx\4y\ty\4z\tz\4{\t",
    "{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080\4\u0081\t\u0081\4\u0082",
    "\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085\t\u0085\4\u0086\t\u0086",
    "\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089\4\u008a\t\u008a\4\u008b",
    "\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e\t\u008e\4\u008f\t\u008f",
    "\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092\4\u0093\t\u0093\4\u0094",
    "\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097\t\u0097\4\u0098\t\u0098",
    "\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b\4\u009c\t\u009c\4\u009d",
    "\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0\t\u00a0\4\u00a1\t\u00a1",
    "\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4\4\u00a5\t\u00a5\4\u00a6",
    "\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9\t\u00a9\4\u00aa\t\u00aa",
    "\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad\3\2\3\2\3\2\6\2\u015e",
    "\n\2\r\2\16\2\u015f\3\2\3\2\3\2\3\2\3\2\3\2\5\2\u0168\n\2\3\2\3\2\3",
    "\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\5\2\u017c",
    "\n\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\7\4\u018b\n",
    "\4\f\4\16\4\u018e\13\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u0197\n\5\3\6",
    "\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6",
    "\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6",
    "\u01bb\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u01c5\n\6\3\6\3\6\3\6",
    "\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\7\6\u01d2\n\6\f\6\16\6\u01d5\13\6\3",
    "\7\3\7\3\7\3\7\3\7\3\7\7\7\u01dd\n\7\f\7\16\7\u01e0\13\7\3\b\3\b\3\b",
    "\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b",
    "\3\b\3\b\5\b\u01f8\n\b\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3",
    "\n\3\n\3\n\5\n\u0208\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13",
    "\3\13\3\13\3\13\7\13\u0216\n\13\f\13\16\13\u0219\13\13\3\f\3\f\3\f\3",
    "\f\3\f\3\f\3\f\3\f\3\f\7\f\u0224\n\f\f\f\16\f\u0227\13\f\3\r\3\r\3\r",
    "\3\r\3\r\3\r\3\r\3\r\3\r\7\r\u0232\n\r\f\r\16\r\u0235\13\r\3\16\3\16",
    "\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\7",
    "\16\u0246\n\16\f\16\16\16\u0249\13\16\3\17\3\17\3\17\3\17\3\17\3\17",
    "\3\17\3\17\3\17\7\17\u0254\n\17\f\17\16\17\u0257\13\17\3\20\3\20\3\20",
    "\3\20\3\20\3\20\7\20\u025f\n\20\f\20\16\20\u0262\13\20\3\21\3\21\3\21",
    "\3\21\3\21\3\21\7\21\u026a\n\21\f\21\16\21\u026d\13\21\3\22\3\22\3\22",
    "\3\22\3\22\3\22\7\22\u0275\n\22\f\22\16\22\u0278\13\22\3\23\3\23\3\23",
    "\3\23\3\23\3\23\7\23\u0280\n\23\f\23\16\23\u0283\13\23\3\24\3\24\3\24",
    "\3\24\3\24\3\24\7\24\u028b\n\24\f\24\16\24\u028e\13\24\3\25\3\25\3\25",
    "\3\25\3\25\3\25\5\25\u0296\n\25\3\26\3\26\3\26\3\26\3\26\5\26\u029d",
    "\n\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\7\30\u02a7\n\30\f\30\16",
    "\30\u02aa\13\30\3\31\3\31\3\32\3\32\5\32\u02b0\n\32\3\32\3\32\3\32\5",
    "\32\u02b5\n\32\3\33\6\33\u02b8\n\33\r\33\16\33\u02b9\3\34\6\34\u02bd",
    "\n\34\r\34\16\34\u02be\3\35\3\35\3\35\3\35\3\35\5\35\u02c6\n\35\3\36",
    "\3\36\3\36\3\36\3\36\3\36\7\36\u02ce\n\36\f\36\16\36\u02d1\13\36\3\37",
    "\3\37\3\37\3\37\3\37\5\37\u02d8\n\37\3 \3 \3!\3!\3!\3!\3!\3!\3!\3!\3",
    "!\3!\3!\3!\3!\3!\5!\u02ea\n!\3\"\3\"\5\"\u02ee\n\"\3\"\3\"\3\"\3\"\3",
    "\"\5\"\u02f5\n\"\3#\3#\3$\3$\3$\3$\3%\3%\3%\3%\3%\7%\u0302\n%\f%\16",
    "%\u0305\13%\3&\3&\5&\u0309\n&\3&\3&\3&\5&\u030e\n&\3\'\3\'\5\'\u0312",
    "\n\'\3\'\3\'\5\'\u0316\n\'\5\'\u0318\n\'\3(\3(\3(\3(\3(\3(\7(\u0320",
    "\n(\f(\16(\u0323\13(\3)\3)\5)\u0327\n)\3)\3)\5)\u032b\n)\3*\3*\5*\u032f",
    "\n*\3*\3*\3*\3*\3*\3*\5*\u0337\n*\3*\3*\3*\3*\3*\3*\3*\5*\u0340\n*\3",
    "+\3+\3+\3+\3+\3+\7+\u0348\n+\f+\16+\u034b\13+\3,\3,\3,\3,\3,\5,\u0352",
    "\n,\3-\3-\3.\3.\3.\3.\3.\3/\3/\3\60\3\60\3\60\3\60\3\60\3\60\5\60\u0363",
    "\n\60\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u036f\n",
    "\61\3\62\5\62\u0372\n\62\3\62\3\62\7\62\u0376\n\62\f\62\16\62\u0379",
    "\13\62\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u0381\n\63\3\63\3\63\3\63",
    "\5\63\u0386\n\63\3\63\5\63\u0389\n\63\3\63\3\63\3\63\3\63\3\63\5\63",
    "\u0390\n\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3",
    "\63\3\63\5\63\u039f\n\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63",
    "\3\63\5\63\u03ab\n\63\3\63\7\63\u03ae\n\63\f\63\16\63\u03b1\13\63\3",
    "\64\3\64\3\64\6\64\u03b6\n\64\r\64\16\64\u03b7\3\64\3\64\5\64\u03bc",
    "\n\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\66\3\66\3\66\7\66\u03c8\n",
    "\66\f\66\16\66\u03cb\13\66\3\66\5\66\u03ce\n\66\3\67\3\67\3\67\5\67",
    "\u03d3\n\67\3\67\5\67\u03d6\n\67\3\67\5\67\u03d9\n\67\38\38\38\38\3",
    "8\78\u03e0\n8\f8\168\u03e3\138\39\39\59\u03e7\n9\39\39\59\u03eb\n9\3",
    "9\39\39\59\u03f0\n9\39\39\59\u03f4\n9\39\59\u03f7\n9\3:\3:\3:\3:\3:",
    "\7:\u03fe\n:\f:\16:\u0401\13:\3;\3;\3;\3;\3;\5;\u0408\n;\3<\3<\3<\3",
    "<\3<\3<\7<\u0410\n<\f<\16<\u0413\13<\3=\3=\3=\3=\3=\5=\u041a\n=\5=\u041c",
    "\n=\3>\3>\3>\3>\3>\3>\7>\u0424\n>\f>\16>\u0427\13>\3?\3?\5?\u042b\n",
    "?\3@\3@\5@\u042f\n@\3@\3@\7@\u0433\n@\f@\16@\u0436\13@\5@\u0438\n@\3",
    "A\3A\3A\3A\3A\7A\u043f\nA\fA\16A\u0442\13A\3A\3A\5A\u0446\nA\3A\5A\u0449",
    "\nA\3A\3A\3A\3A\5A\u044f\nA\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3",
    "A\5A\u045f\nA\3A\3A\7A\u0463\nA\fA\16A\u0466\13A\5A\u0468\nA\3A\3A\3",
    "A\5A\u046d\nA\3A\5A\u0470\nA\3A\3A\3A\3A\3A\5A\u0477\nA\3A\3A\3A\3A",
    "\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u048a\nA\3A\3A\7A\u048e\n",
    "A\fA\16A\u0491\13A\7A\u0493\nA\fA\16A\u0496\13A\3B\3B\3C\3C\3C\3C\3",
    "C\3C\3C\3C\3C\3C\5C\u04a4\nC\3D\3D\5D\u04a8\nD\3D\3D\3D\3D\3D\5D\u04af",
    "\nD\3D\7D\u04b2\nD\fD\16D\u04b5\13D\3E\3E\3E\3F\3F\3F\3F\3F\7F\u04bf",
    "\nF\fF\16F\u04c2\13F\3G\3G\3G\3G\3G\3G\5G\u04ca\nG\3H\3H\3H\3H\3H\6",
    "H\u04d1\nH\rH\16H\u04d2\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3",
    "I\7I\u04e4\nI\fI\16I\u04e7\13I\5I\u04e9\nI\3I\3I\3I\3I\7I\u04ef\nI\f",
    "I\16I\u04f2\13I\5I\u04f4\nI\7I\u04f6\nI\fI\16I\u04f9\13I\3I\3I\5I\u04fd",
    "\nI\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\5J\u050a\nJ\3K\3K\5K\u050e\nK\3",
    "K\3K\3L\3L\3L\3L\3L\7L\u0517\nL\fL\16L\u051a\13L\3M\3M\3M\5M\u051f\n",
    "M\3N\3N\3N\3N\3N\3N\3O\5O\u0528\nO\3O\3O\3P\3P\3P\3P\3P\3P\3P\5P\u0533",
    "\nP\3P\3P\3P\3P\3P\3P\5P\u053b\nP\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3",
    "Q\3Q\3Q\3Q\3Q\3Q\5Q\u054e\nQ\3Q\3Q\5Q\u0552\nQ\3Q\3Q\5Q\u0556\nQ\3Q",
    "\3Q\3Q\3Q\3Q\3Q\5Q\u055e\nQ\3Q\3Q\5Q\u0562\nQ\3Q\3Q\3Q\5Q\u0567\nQ\3",
    "R\3R\3R\3R\3R\3R\3R\3R\3R\5R\u0572\nR\3R\3R\3R\3R\3R\5R\u0579\nR\3S",
    "\5S\u057c\nS\3S\3S\5S\u0580\nS\3T\3T\3T\3T\3T\7T\u0587\nT\fT\16T\u058a",
    "\13T\3U\3U\3U\5U\u058f\nU\3V\5V\u0592\nV\3V\3V\5V\u0596\nV\3V\3V\3W",
    "\3W\3W\3W\3W\7W\u059f\nW\fW\16W\u05a2\13W\3X\3X\3X\3X\3X\6X\u05a9\n",
    "X\rX\16X\u05aa\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u05b7\nX\3X\3X\3X\3",
    "X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\3X\5X\u05cd\nX\3Y\3Y",
    "\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\5Z\u05df\nZ\3[\3[\3[\3[\3",
    "[\3[\3[\3[\3[\3[\5[\u05eb\n[\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\",
    "\3\\\3\\\5\\\u05f9\n\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3",
    "\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3",
    "\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3",
    "\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\3\\\5\\\u0634\n\\\3]\3]\3",
    "]\3]\3]\3]\3]\3]\5]\u063e\n]\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^",
    "\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\3^\5^\u0661",
    "\n^\3_\3_\3_\3_\3_\3_\3_\5_\u066a\n_\3`\3`\3`\3`\3`\3`\3`\3`\3`\3`\3",
    "`\3`\3`\3`\3`\3`\5`\u067c\n`\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a\3a",
    "\3a\3a\3a\3a\3a\5a\u0690\na\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\3b\5",
    "b\u069f\nb\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\3c\5c\u06ae\nc\3d\3d",
    "\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\3d\5d\u06c7",
    "\nd\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e\u06d6\ne\3f\3f\3f\3f\3",
    "f\3f\3f\3f\5f\u06e0\nf\3g\3g\3g\3g\3g\3g\3g\3g\5g\u06ea\ng\3h\3h\3h",
    "\3h\3h\3h\3h\3h\5h\u06f4\nh\3i\3i\3i\3i\3i\3i\3i\3i\5i\u06fe\ni\3j\3",
    "j\3j\3j\3j\3j\3j\3j\5j\u0708\nj\3k\3k\3k\3k\3k\3k\5k\u0710\nk\3k\3k",
    "\3l\3l\3l\3l\3l\3l\3l\3l\5l\u071c\nl\3m\3m\3m\3m\3m\3m\3m\3m\3m\3m\3",
    "m\3m\5m\u072a\nm\3n\3n\3n\3n\3n\3n\3n\3n\5n\u0734\nn\3o\3o\3o\3p\3p",
    "\5p\u073b\np\3p\3p\3p\3p\3p\3p\5p\u0743\np\3q\6q\u0746\nq\rq\16q\u0747",
    "\3q\3q\3r\6r\u074d\nr\rr\16r\u074e\3r\3r\3s\3s\3s\3s\3s\3s\3s\3s\3s",
    "\3s\3s\3s\3s\3s\3s\5s\u0762\ns\3t\3t\3t\3t\3t\3t\3t\3t\5t\u076c\nt\3",
    "u\3u\3u\3u\3u\3u\3u\3u\5u\u0776\nu\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v\3v",
    "\3v\5v\u0784\nv\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3",
    "w\3w\3w\3w\3w\3w\3w\3w\3w\3w\5w\u07a1\nw\3w\3w\3w\3w\3w\3w\3w\3w\3w",
    "\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\3w\5w\u07ba\nw\3x\3x\5x\u07be",
    "\nx\3x\3x\3x\3x\3x\3x\3x\5x\u07c7\nx\3y\3y\3y\3y\5y\u07cd\ny\3z\3z\3",
    "z\3z\3z\3{\3{\3{\3{\3{\3{\3{\5{\u07db\n{\3|\3|\5|\u07df\n|\3|\3|\3|",
    "\3|\3|\3|\5|\u07e7\n|\3}\3}\5}\u07eb\n}\3}\3}\3}\3}\5}\u07f1\n}\3}\3",
    "}\5}\u07f5\n}\3~\3~\3~\3~\3~\3~\3~\3~\5~\u07ff\n~\3\177\3\177\3\177",
    "\3\177\5\177\u0805\n\177\3\177\3\177\3\177\3\177\5\177\u080b\n\177\3",
    "\u0080\3\u0080\5\u0080\u080f\n\u0080\3\u0080\3\u0080\3\u0080\3\u0080",
    "\3\u0080\3\u0080\3\u0080\5\u0080\u0818\n\u0080\3\u0080\3\u0080\3\u0080",
    "\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\5\u0080\u0823\n\u0080",
    "\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\5\u0081",
    "\u082d\n\u0081\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082",
    "\3\u0082\5\u0082\u0837\n\u0082\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084",
    "\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085",
    "\3\u0085\3\u0085\3\u0085\5\u0085\u084a\n\u0085\3\u0086\3\u0086\3\u0086",
    "\3\u0086\3\u0086\3\u0086\5\u0086\u0852\n\u0086\3\u0086\3\u0086\3\u0086",
    "\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u085d\n\u0086",
    "\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087",
    "\3\u0087\3\u0087\3\u0087\5\u0087\u086b\n\u0087\3\u0088\5\u0088\u086e",
    "\n\u0088\3\u0088\3\u0088\7\u0088\u0872\n\u0088\f\u0088\16\u0088\u0875",
    "\13\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3",
    "\u0089\3\u0089\3\u0089\3\u0089\3\u0089\5\u0089\u0883\n\u0089\3\u0089",
    "\5\u0089\u0886\n\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089",
    "\3\u0089\5\u0089\u088f\n\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089",
    "\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089",
    "\3\u0089\5\u0089\u08a0\n\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089",
    "\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\3\u0089\5\u0089",
    "\u08af\n\u0089\3\u0089\3\u0089\3\u0089\5\u0089\u08b4\n\u0089\3\u008a",
    "\3\u008a\3\u008a\6\u008a\u08b9\n\u008a\r\u008a\16\u008a\u08ba\3\u008a",
    "\3\u008a\3\u008a\3\u008a\3\u008a\5\u008a\u08c2\n\u008a\3\u008b\3\u008b",
    "\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008b\3\u008c\3\u008c\3\u008c",
    "\7\u008c\u08cf\n\u008c\f\u008c\16\u008c\u08d2\13\u008c\3\u008c\3\u008c",
    "\3\u008c\5\u008c\u08d7\n\u008c\3\u008d\3\u008d\3\u008d\5\u008d\u08dc",
    "\n\u008d\3\u008d\5\u008d\u08df\n\u008d\3\u008d\5\u008d\u08e2\n\u008d",
    "\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\3\u008e\7\u008e\u08eb",
    "\n\u008e\f\u008e\16\u008e\u08ee\13\u008e\3\u008f\3\u008f\5\u008f\u08f2",
    "\n\u008f\3\u008f\3\u008f\3\u008f\5\u008f\u08f7\n\u008f\3\u008f\3\u008f",
    "\3\u008f\3\u008f\3\u008f\5\u008f\u08fe\n\u008f\3\u008f\3\u008f\5\u008f",
    "\u0902\n\u008f\3\u008f\5\u008f\u0905\n\u008f\3\u0090\3\u0090\3\u0090",
    "\3\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u090e\n\u0090\3\u0091\3\u0091",
    "\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\3\u0091\5\u0091\u0918\n\u0091",
    "\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\5\u0092",
    "\u0922\n\u0092\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\3\u0093\5\u0093",
    "\u092a\n\u0093\3\u0093\3\u0093\5\u0093\u092e\n\u0093\3\u0094\3\u0094",
    "\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\5\u0094\u0937\n\u0094\3\u0095",
    "\3\u0095\5\u0095\u093b\n\u0095\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096",
    "\3\u0096\5\u0096\u0943\n\u0096\3\u0096\3\u0096\7\u0096\u0947\n\u0096",
    "\f\u0096\16\u0096\u094a\13\u0096\3\u0096\3\u0096\5\u0096\u094e\n\u0096",
    "\3\u0097\3\u0097\3\u0097\3\u0097\7\u0097\u0954\n\u0097\f\u0097\16\u0097",
    "\u0957\13\u0097\3\u0097\3\u0097\3\u0097\3\u0097\5\u0097\u095d\n\u0097",
    "\3\u0097\5\u0097\u0960\n\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097",
    "\5\u0097\u0967\n\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097",
    "\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097",
    "\3\u0097\3\u0097\5\u0097\u097a\n\u0097\3\u0097\3\u0097\7\u0097\u097e",
    "\n\u0097\f\u0097\16\u0097\u0981\13\u0097\3\u0097\3\u0097\3\u0097\3\u0097",
    "\5\u0097\u0987\n\u0097\3\u0097\5\u0097\u098a\n\u0097\3\u0097\3\u0097",
    "\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\5\u0097\u0993\n\u0097\3\u0097",
    "\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097",
    "\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097",
    "\3\u0097\3\u0097\5\u0097\u09aa\n\u0097\3\u0097\3\u0097\7\u0097\u09ae",
    "\n\u0097\f\u0097\16\u0097\u09b1\13\u0097\3\u0097\3\u0097\5\u0097\u09b5",
    "\n\u0097\3\u0098\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099",
    "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099",
    "\5\u0099\u09c8\n\u0099\3\u009a\5\u009a\u09cb\n\u009a\3\u009a\3\u009a",
    "\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u09d3\n\u009a\3\u009a\3\u009a",
    "\3\u009a\5\u009a\u09d8\n\u009a\3\u009b\3\u009b\3\u009b\3\u009b\3\u009c",
    "\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\5\u009c\u09e5\n\u009c",
    "\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\3\u009d\5\u009d",
    "\u09ef\n\u009d\3\u009e\3\u009e\3\u009e\3\u009e\3\u009e\6\u009e\u09f6",
    "\n\u009e\r\u009e\16\u009e\u09f7\3\u009e\3\u009e\3\u009e\3\u009e\3\u009f",
    "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f",
    "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f",
    "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\7\u009f\u0a16\n\u009f\f\u009f",
    "\16\u009f\u0a19\13\u009f\5\u009f\u0a1b\n\u009f\3\u009f\3\u009f\3\u009f",
    "\3\u009f\7\u009f\u0a21\n\u009f\f\u009f\16\u009f\u0a24\13\u009f\5\u009f",
    "\u0a26\n\u009f\7\u009f\u0a28\n\u009f\f\u009f\16\u009f\u0a2b\13\u009f",
    "\3\u009f\3\u009f\3\u009f\5\u009f\u0a30\n\u009f\3\u00a0\3\u00a0\3\u00a0",
    "\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0\3\u00a0",
    "\3\u00a0\3\u00a0\3\u00a0\3\u00a0\5\u00a0\u0a42\n\u00a0\3\u00a1\3\u00a1",
    "\5\u00a1\u0a46\n\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a2",
    "\3\u00a2\3\u00a2\3\u00a2\3\u00a2\5\u00a2\u0a52\n\u00a2\3\u00a3\3\u00a3",
    "\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\3\u00a3\5\u00a3",
    "\u0a5e\n\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4",
    "\3\u00a5\5\u00a5\u0a68\n\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6",
    "\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\5\u00a6\u0a74\n\u00a6\3\u00a6",
    "\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\5\u00a6",
    "\u0a7f\n\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7",
    "\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7",
    "\3\u00a7\3\u00a7\3\u00a7\5\u00a7\u0a94\n\u00a7\3\u00a7\3\u00a7\5\u00a7",
    "\u0a98\n\u00a7\3\u00a7\3\u00a7\5\u00a7\u0a9c\n\u00a7\3\u00a7\3\u00a7",
    "\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\5\u00a7\u0aa6\n\u00a7",
    "\3\u00a7\3\u00a7\5\u00a7\u0aaa\n\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7",
    "\5\u00a7\u0ab0\n\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8",
    "\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0abe\n\u00a8",
    "\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0ac6\n\u00a8",
    "\3\u00a9\5\u00a9\u0ac9\n\u00a9\3\u00a9\3\u00a9\5\u00a9\u0acd\n\u00a9",
    "\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa\5\u00aa\u0ad6",
    "\n\u00aa\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\5\u00ab",
    "\u0adf\n\u00ab\3\u00ac\5\u00ac\u0ae2\n\u00ac\3\u00ac\3\u00ac\5\u00ac",
    "\u0ae6\n\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad",
    "\3\u00ad\3\u00ad\3\u00ad\5\u00ad\u0af2\n\u00ad\3\u00ad\2\36\6\n\f\24",
    "\26\30\32\34\36 \"$&.:HNTdrvz\u0080\u0086\u008a\u0096\u00a6\u00ac\u00ae",
    "\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BD",
    "FHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c",
    "\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4",
    "\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc",
    "\u00be\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4",
    "\u00d6\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec",
    "\u00ee\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104",
    "\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c",
    "\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134",
    "\u0136\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c",
    "\u014e\u0150\u0152\u0154\u0156\u0158\2\16\7\2IIKKMMPPUV\3\2[e\b\2\21",
    "\21\34\34$$**--<<\n\2\6\b\24\24\31\31\35\35\"#\'(/\60\66\67\3\2\6\b",
    "\4\2++..\6\2\25\25%%\61\61\65\65\5\2\n\13!!::\4\2=>ZZ\3\2=>\4\2\r\r",
    "\17\17\4\2\20\20\61\61\u0bfe\2\u017b\3\2\2\2\4\u017d\3\2\2\2\6\u0184",
    "\3\2\2\2\b\u0196\3\2\2\2\n\u01ba\3\2\2\2\f\u01d6\3\2\2\2\16\u01f7\3",
    "\2\2\2\20\u01f9\3\2\2\2\22\u0207\3\2\2\2\24\u0209\3\2\2\2\26\u021a\3",
    "\2\2\2\30\u0228\3\2\2\2\32\u0236\3\2\2\2\34\u024a\3\2\2\2\36\u0258\3",
    "\2\2\2 \u0263\3\2\2\2\"\u026e\3\2\2\2$\u0279\3\2\2\2&\u0284\3\2\2\2",
    "(\u028f\3\2\2\2*\u029c\3\2\2\2,\u029e\3\2\2\2.\u02a0\3\2\2\2\60\u02ab",
    "\3\2\2\2\62\u02b4\3\2\2\2\64\u02b7\3\2\2\2\66\u02bc\3\2\2\28\u02c5\3",
    "\2\2\2:\u02c7\3\2\2\2<\u02d7\3\2\2\2>\u02d9\3\2\2\2@\u02e9\3\2\2\2B",
    "\u02f4\3\2\2\2D\u02f6\3\2\2\2F\u02f8\3\2\2\2H\u02fc\3\2\2\2J\u030d\3",
    "\2\2\2L\u0317\3\2\2\2N\u0319\3\2\2\2P\u032a\3\2\2\2R\u033f\3\2\2\2T",
    "\u0341\3\2\2\2V\u0351\3\2\2\2X\u0353\3\2\2\2Z\u0355\3\2\2\2\\\u035a",
    "\3\2\2\2^\u0362\3\2\2\2`\u036e\3\2\2\2b\u0371\3\2\2\2d\u0380\3\2\2\2",
    "f\u03bb\3\2\2\2h\u03bd\3\2\2\2j\u03cd\3\2\2\2l\u03d8\3\2\2\2n\u03e1",
    "\3\2\2\2p\u03f6\3\2\2\2r\u03f8\3\2\2\2t\u0407\3\2\2\2v\u0409\3\2\2\2",
    "x\u041b\3\2\2\2z\u041d\3\2\2\2|\u0428\3\2\2\2~\u0437\3\2\2\2\u0080\u0467",
    "\3\2\2\2\u0082\u0497\3\2\2\2\u0084\u04a3\3\2\2\2\u0086\u04a5\3\2\2\2",
    "\u0088\u04b6\3\2\2\2\u008a\u04b9\3\2\2\2\u008c\u04c9\3\2\2\2\u008e\u04cb",
    "\3\2\2\2\u0090\u04fc\3\2\2\2\u0092\u0509\3\2\2\2\u0094\u050b\3\2\2\2",
    "\u0096\u0511\3\2\2\2\u0098\u051e\3\2\2\2\u009a\u0520\3\2\2\2\u009c\u0527",
    "\3\2\2\2\u009e\u053a\3\2\2\2\u00a0\u0566\3\2\2\2\u00a2\u0578\3\2\2\2",
    "\u00a4\u057f\3\2\2\2\u00a6\u0581\3\2\2\2\u00a8\u058e\3\2\2\2\u00aa\u0591",
    "\3\2\2\2\u00ac\u0599\3\2\2\2\u00ae\u05cc\3\2\2\2\u00b0\u05ce\3\2\2\2",
    "\u00b2\u05de\3\2\2\2\u00b4\u05ea\3\2\2\2\u00b6\u0633\3\2\2\2\u00b8\u063d",
    "\3\2\2\2\u00ba\u0660\3\2\2\2\u00bc\u0669\3\2\2\2\u00be\u067b\3\2\2\2",
    "\u00c0\u068f\3\2\2\2\u00c2\u069e\3\2\2\2\u00c4\u06ad\3\2\2\2\u00c6\u06c6",
    "\3\2\2\2\u00c8\u06d5\3\2\2\2\u00ca\u06df\3\2\2\2\u00cc\u06e9\3\2\2\2",
    "\u00ce\u06f3\3\2\2\2\u00d0\u06fd\3\2\2\2\u00d2\u0707\3\2\2\2\u00d4\u0709",
    "\3\2\2\2\u00d6\u071b\3\2\2\2\u00d8\u0729\3\2\2\2\u00da\u0733\3\2\2\2",
    "\u00dc\u0735\3\2\2\2\u00de\u0742\3\2\2\2\u00e0\u0745\3\2\2\2\u00e2\u074c",
    "\3\2\2\2\u00e4\u0761\3\2\2\2\u00e6\u076b\3\2\2\2\u00e8\u0775\3\2\2\2",
    "\u00ea\u0783\3\2\2\2\u00ec\u07b9\3\2\2\2\u00ee\u07c6\3\2\2\2\u00f0\u07cc",
    "\3\2\2\2\u00f2\u07ce\3\2\2\2\u00f4\u07da\3\2\2\2\u00f6\u07e6\3\2\2\2",
    "\u00f8\u07f4\3\2\2\2\u00fa\u07fe\3\2\2\2\u00fc\u080a\3\2\2\2\u00fe\u0822",
    "\3\2\2\2\u0100\u082c\3\2\2\2\u0102\u0836\3\2\2\2\u0104\u0838\3\2\2\2",
    "\u0106\u083b\3\2\2\2\u0108\u0849\3\2\2\2\u010a\u085c\3\2\2\2\u010c\u086a",
    "\3\2\2\2\u010e\u086d\3\2\2\2\u0110\u08b3\3\2\2\2\u0112\u08c1\3\2\2\2",
    "\u0114\u08c3\3\2\2\2\u0116\u08d6\3\2\2\2\u0118\u08e1\3\2\2\2\u011a\u08ec",
    "\3\2\2\2\u011c\u0904\3\2\2\2\u011e\u090d\3\2\2\2\u0120\u0917\3\2\2\2",
    "\u0122\u0921\3\2\2\2\u0124\u092d\3\2\2\2\u0126\u0936\3\2\2\2\u0128\u0938",
    "\3\2\2\2\u012a\u094d\3\2\2\2\u012c\u09b4\3\2\2\2\u012e\u09b6\3\2\2\2",
    "\u0130\u09c7\3\2\2\2\u0132\u09d7\3\2\2\2\u0134\u09d9\3\2\2\2\u0136\u09e4",
    "\3\2\2\2\u0138\u09ee\3\2\2\2\u013a\u09f0\3\2\2\2\u013c\u0a2f\3\2\2\2",
    "\u013e\u0a41\3\2\2\2\u0140\u0a43\3\2\2\2\u0142\u0a51\3\2\2\2\u0144\u0a5d",
    "\3\2\2\2\u0146\u0a5f\3\2\2\2\u0148\u0a67\3\2\2\2\u014a\u0a7e\3\2\2\2",
    "\u014c\u0aaf\3\2\2\2\u014e\u0ac5\3\2\2\2\u0150\u0acc\3\2\2\2\u0152\u0ad5",
    "\3\2\2\2\u0154\u0ade\3\2\2\2\u0156\u0ae1\3\2\2\2\u0158\u0af1\3\2\2\2",
    "\u015a\u017c\7k\2\2\u015b\u017c\7l\2\2\u015c\u015e\7m\2\2\u015d\u015c",
    "\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u015d\3\2\2\2\u015f\u0160\3\2\2\2",
    "\u0160\u017c\3\2\2\2\u0161\u0162\7=\2\2\u0162\u0163\5.\30\2\u0163\u0164",
    "\7>\2\2\u0164\u017c\3\2\2\2\u0165\u017c\5\4\3\2\u0166\u0168\7\3\2\2",
    "\u0167\u0166\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u016a",
    "\7=\2\2\u016a\u016b\5\u0094K\2\u016b\u016c\7>\2\2\u016c\u017c\3\2\2",
    "\2\u016d\u016e\7\4\2\2\u016e\u016f\7=\2\2\u016f\u0170\5\16\b\2\u0170",
    "\u0171\7Z\2\2\u0171\u0172\5|?\2\u0172\u0173\7>\2\2\u0173\u017c\3\2\2",
    "\2\u0174\u0175\7\5\2\2\u0175\u0176\7=\2\2\u0176\u0177\5|?\2\u0177\u0178",
    "\7Z\2\2\u0178\u0179\5\16\b\2\u0179\u017a\7>\2\2\u017a\u017c\3\2\2\2",
    "\u017b\u015a\3\2\2\2\u017b\u015b\3\2\2\2\u017b\u015d\3\2\2\2\u017b\u0161",
    "\3\2\2\2\u017b\u0165\3\2\2\2\u017b\u0167\3\2\2\2\u017b\u016d\3\2\2\2",
    "\u017b\u0174\3\2\2\2\u017c\3\3\2\2\2\u017d\u017e\78\2\2\u017e\u017f",
    "\7=\2\2\u017f\u0180\5*\26\2\u0180\u0181\7Z\2\2\u0181\u0182\5\6\4\2\u0182",
    "\u0183\7>\2\2\u0183\5\3\2\2\2\u0184\u0185\b\4\1\2\u0185\u0186\5\b\5",
    "\2\u0186\u018c\3\2\2\2\u0187\u0188\f\3\2\2\u0188\u0189\7Z\2\2\u0189",
    "\u018b\5\b\5\2\u018a\u0187\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3",
    "\2\2\2\u018c\u018d\3\2\2\2\u018d\7\3\2\2\2\u018e\u018c\3\2\2\2\u018f",
    "\u0190\5|?\2\u0190\u0191\7X\2\2\u0191\u0192\5*\26\2\u0192\u0197\3\2",
    "\2\2\u0193\u0194\7\27\2\2\u0194\u0195\7X\2\2\u0195\u0197\5*\26\2\u0196",
    "\u018f\3\2\2\2\u0196\u0193\3\2\2\2\u0197\t\3\2\2\2\u0198\u0199\b\6\1",
    "\2\u0199\u01bb\5\2\2\2\u019a\u019b\7=\2\2\u019b\u019c\5|?\2\u019c\u019d",
    "\7>\2\2\u019d\u019e\7A\2\2\u019e\u019f\5\u0086D\2\u019f\u01a0\7B\2\2",
    "\u01a0\u01bb\3\2\2\2\u01a1\u01a2\7=\2\2\u01a2\u01a3\5|?\2\u01a3\u01a4",
    "\7>\2\2\u01a4\u01a5\7A\2\2\u01a5\u01a6\5\u0086D\2\u01a6\u01a7\7Z\2\2",
    "\u01a7\u01a8\7B\2\2\u01a8\u01bb\3\2\2\2\u01a9\u01aa\7\3\2\2\u01aa\u01ab",
    "\7=\2\2\u01ab\u01ac\5|?\2\u01ac\u01ad\7>\2\2\u01ad\u01ae\7A\2\2\u01ae",
    "\u01af\5\u0086D\2\u01af\u01b0\7B\2\2\u01b0\u01bb\3\2\2\2\u01b1\u01b2",
    "\7\3\2\2\u01b2\u01b3\7=\2\2\u01b3\u01b4\5|?\2\u01b4\u01b5\7>\2\2\u01b5",
    "\u01b6\7A\2\2\u01b6\u01b7\5\u0086D\2\u01b7\u01b8\7Z\2\2\u01b8\u01b9",
    "\7B\2\2\u01b9\u01bb\3\2\2\2\u01ba\u0198\3\2\2\2\u01ba\u019a\3\2\2\2",
    "\u01ba\u01a1\3\2\2\2\u01ba\u01a9\3\2\2\2\u01ba\u01b1\3\2\2\2\u01bb\u01d3",
    "\3\2\2\2\u01bc\u01bd\f\f\2\2\u01bd\u01be\7?\2\2\u01be\u01bf\5.\30\2",
    "\u01bf\u01c0\7@\2\2\u01c0\u01d2\3\2\2\2\u01c1\u01c2\f\13\2\2\u01c2\u01c4",
    "\7=\2\2\u01c3\u01c5\5\f\7\2\u01c4\u01c3\3\2\2\2\u01c4\u01c5\3\2\2\2",
    "\u01c5\u01c6\3\2\2\2\u01c6\u01d2\7>\2\2\u01c7\u01c8\f\n\2\2\u01c8\u01c9",
    "\7i\2\2\u01c9\u01d2\7k\2\2\u01ca\u01cb\f\t\2\2\u01cb\u01cc\7h\2\2\u01cc",
    "\u01d2\7k\2\2\u01cd\u01ce\f\b\2\2\u01ce\u01d2\7J\2\2\u01cf\u01d0\f\7",
    "\2\2\u01d0\u01d2\7L\2\2\u01d1\u01bc\3\2\2\2\u01d1\u01c1\3\2\2\2\u01d1",
    "\u01c7\3\2\2\2\u01d1\u01ca\3\2\2\2\u01d1\u01cd\3\2\2\2\u01d1\u01cf\3",
    "\2\2\2\u01d2\u01d5\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4",
    "\13\3\2\2\2\u01d5\u01d3\3\2\2\2\u01d6\u01d7\b\7\1\2\u01d7\u01d8\5*\26",
    "\2\u01d8\u01de\3\2\2\2\u01d9\u01da\f\3\2\2\u01da\u01db\7Z\2\2\u01db",
    "\u01dd\5*\26\2\u01dc\u01d9\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de\u01dc\3",
    "\2\2\2\u01de\u01df\3\2\2\2\u01df\r\3\2\2\2\u01e0\u01de\3\2\2\2\u01e1",
    "\u01f8\5\n\6\2\u01e2\u01e3\7J\2\2\u01e3\u01f8\5\16\b\2\u01e4\u01e5\7",
    "L\2\2\u01e5\u01f8\5\16\b\2\u01e6\u01e7\5\20\t\2\u01e7\u01e8\5\22\n\2",
    "\u01e8\u01f8\3\2\2\2\u01e9\u01ea\7)\2\2\u01ea\u01f8\5\16\b\2\u01eb\u01ec",
    "\7)\2\2\u01ec\u01ed\7=\2\2\u01ed\u01ee\5|?\2\u01ee\u01ef\7>\2\2\u01ef",
    "\u01f8\3\2\2\2\u01f0\u01f1\7\64\2\2\u01f1\u01f2\7=\2\2\u01f2\u01f3\5",
    "|?\2\u01f3\u01f4\7>\2\2\u01f4\u01f8\3\2\2\2\u01f5\u01f6\7R\2\2\u01f6",
    "\u01f8\7k\2\2\u01f7\u01e1\3\2\2\2\u01f7\u01e2\3\2\2\2\u01f7\u01e4\3",
    "\2\2\2\u01f7\u01e6\3\2\2\2\u01f7\u01e9\3\2\2\2\u01f7\u01eb\3\2\2\2\u01f7",
    "\u01f0\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f8\17\3\2\2\2\u01f9\u01fa\t\2",
    "\2\2\u01fa\21\3\2\2\2\u01fb\u0208\5\16\b\2\u01fc\u01fd\7=\2\2\u01fd",
    "\u01fe\5|?\2\u01fe\u01ff\7>\2\2\u01ff\u0200\5\22\n\2\u0200\u0208\3\2",
    "\2\2\u0201\u0202\7\3\2\2\u0202\u0203\7=\2\2\u0203\u0204\5|?\2\u0204",
    "\u0205\7>\2\2\u0205\u0206\5\22\n\2\u0206\u0208\3\2\2\2\u0207\u01fb\3",
    "\2\2\2\u0207\u01fc\3\2\2\2\u0207\u0201\3\2\2\2\u0208\23\3\2\2\2\u0209",
    "\u020a\b\13\1\2\u020a\u020b\5\22\n\2\u020b\u0217\3\2\2\2\u020c\u020d",
    "\f\5\2\2\u020d\u020e\7M\2\2\u020e\u0216\5\22\n\2\u020f\u0210\f\4\2\2",
    "\u0210\u0211\7N\2\2\u0211\u0216\5\22\n\2\u0212\u0213\f\3\2\2\u0213\u0214",
    "\7O\2\2\u0214\u0216\5\22\n\2\u0215\u020c\3\2\2\2\u0215\u020f\3\2\2\2",
    "\u0215\u0212\3\2\2\2\u0216\u0219\3\2\2\2\u0217\u0215\3\2\2\2\u0217\u0218",
    "\3\2\2\2\u0218\25\3\2\2\2\u0219\u0217\3\2\2\2\u021a\u021b\b\f\1\2\u021b",
    "\u021c\5\24\13\2\u021c\u0225\3\2\2\2\u021d\u021e\f\4\2\2\u021e\u021f",
    "\7I\2\2\u021f\u0224\5\24\13\2\u0220\u0221\f\3\2\2\u0221\u0222\7K\2\2",
    "\u0222\u0224\5\24\13\2\u0223\u021d\3\2\2\2\u0223\u0220\3\2\2\2\u0224",
    "\u0227\3\2\2\2\u0225\u0223\3\2\2\2\u0225\u0226\3\2\2\2\u0226\27\3\2",
    "\2\2\u0227\u0225\3\2\2\2\u0228\u0229\b\r\1\2\u0229\u022a\5\26\f\2\u022a",
    "\u0233\3\2\2\2\u022b\u022c\f\4\2\2\u022c\u022d\7G\2\2\u022d\u0232\5",
    "\26\f\2\u022e\u022f\f\3\2\2\u022f\u0230\7H\2\2\u0230\u0232\5\26\f\2",
    "\u0231\u022b\3\2\2\2\u0231\u022e\3\2\2\2\u0232\u0235\3\2\2\2\u0233\u0231",
    "\3\2\2\2\u0233\u0234\3\2\2\2\u0234\31\3\2\2\2\u0235\u0233\3\2\2\2\u0236",
    "\u0237\b\16\1\2\u0237\u0238\5\30\r\2\u0238\u0247\3\2\2\2\u0239\u023a",
    "\f\6\2\2\u023a\u023b\7C\2\2\u023b\u0246\5\30\r\2\u023c\u023d\f\5\2\2",
    "\u023d\u023e\7E\2\2\u023e\u0246\5\30\r\2\u023f\u0240\f\4\2\2\u0240\u0241",
    "\7D\2\2\u0241\u0246\5\30\r\2\u0242\u0243\f\3\2\2\u0243\u0244\7F\2\2",
    "\u0244\u0246\5\30\r\2\u0245\u0239\3\2\2\2\u0245\u023c\3\2\2\2\u0245",
    "\u023f\3\2\2\2\u0245\u0242\3\2\2\2\u0246\u0249\3\2\2\2\u0247\u0245\3",
    "\2\2\2\u0247\u0248\3\2\2\2\u0248\33\3\2\2\2\u0249\u0247\3\2\2\2\u024a",
    "\u024b\b\17\1\2\u024b\u024c\5\32\16\2\u024c\u0255\3\2\2\2\u024d\u024e",
    "\f\4\2\2\u024e\u024f\7f\2\2\u024f\u0254\5\32\16\2\u0250\u0251\f\3\2",
    "\2\u0251\u0252\7g\2\2\u0252\u0254\5\32\16\2\u0253\u024d\3\2\2\2\u0253",
    "\u0250\3\2\2\2\u0254\u0257\3\2\2\2\u0255\u0253\3\2\2\2\u0255\u0256\3",
    "\2\2\2\u0256\35\3\2\2\2\u0257\u0255\3\2\2\2\u0258\u0259\b\20\1\2\u0259",
    "\u025a\5\34\17\2\u025a\u0260\3\2\2\2\u025b\u025c\f\3\2\2\u025c\u025d",
    "\7P\2\2\u025d\u025f\5\34\17\2\u025e\u025b\3\2\2\2\u025f\u0262\3\2\2",
    "\2\u0260\u025e\3\2\2\2\u0260\u0261\3\2\2\2\u0261\37\3\2\2\2\u0262\u0260",
    "\3\2\2\2\u0263\u0264\b\21\1\2\u0264\u0265\5\36\20\2\u0265\u026b\3\2",
    "\2\2\u0266\u0267\f\3\2\2\u0267\u0268\7T\2\2\u0268\u026a\5\36\20\2\u0269",
    "\u0266\3\2\2\2\u026a\u026d\3\2\2\2\u026b\u0269\3\2\2\2\u026b\u026c\3",
    "\2\2\2\u026c!\3\2\2\2\u026d\u026b\3\2\2\2\u026e\u026f\b\22\1\2\u026f",
    "\u0270\5 \21\2\u0270\u0276\3\2\2\2\u0271\u0272\f\3\2\2\u0272\u0273\7",
    "Q\2\2\u0273\u0275\5 \21\2\u0274\u0271\3\2\2\2\u0275\u0278\3\2\2\2\u0276",
    "\u0274\3\2\2\2\u0276\u0277\3\2\2\2\u0277#\3\2\2\2\u0278\u0276\3\2\2",
    "\2\u0279\u027a\b\23\1\2\u027a\u027b\5\"\22\2\u027b\u0281\3\2\2\2\u027c",
    "\u027d\f\3\2\2\u027d\u027e\7R\2\2\u027e\u0280\5\"\22\2\u027f\u027c\3",
    "\2\2\2\u0280\u0283\3\2\2\2\u0281\u027f\3\2\2\2\u0281\u0282\3\2\2\2\u0282",
    "%\3\2\2\2\u0283\u0281\3\2\2\2\u0284\u0285\b\24\1\2\u0285\u0286\5$\23",
    "\2\u0286\u028c\3\2\2\2\u0287\u0288\f\3\2\2\u0288\u0289\7S\2\2\u0289",
    "\u028b\5$\23\2\u028a\u0287\3\2\2\2\u028b\u028e\3\2\2\2\u028c\u028a\3",
    "\2\2\2\u028c\u028d\3\2\2\2\u028d\'\3\2\2\2\u028e\u028c\3\2\2\2\u028f",
    "\u0295\5&\24\2\u0290\u0291\7W\2\2\u0291\u0292\5.\30\2\u0292\u0293\7",
    "X\2\2\u0293\u0294\5(\25\2\u0294\u0296\3\2\2\2\u0295\u0290\3\2\2\2\u0295",
    "\u0296\3\2\2\2\u0296)\3\2\2\2\u0297\u029d\5(\25\2\u0298\u0299\5\16\b",
    "\2\u0299\u029a\5,\27\2\u029a\u029b\5*\26\2\u029b\u029d\3\2\2\2\u029c",
    "\u0297\3\2\2\2\u029c\u0298\3\2\2\2\u029d+\3\2\2\2\u029e\u029f\t\3\2",
    "\2\u029f-\3\2\2\2\u02a0\u02a1\b\30\1\2\u02a1\u02a2\5*\26\2\u02a2\u02a8",
    "\3\2\2\2\u02a3\u02a4\f\3\2\2\u02a4\u02a5\7Z\2\2\u02a5\u02a7\5*\26\2",
    "\u02a6\u02a3\3\2\2\2\u02a7\u02aa\3\2\2\2\u02a8\u02a6\3\2\2\2\u02a8\u02a9",
    "\3\2\2\2\u02a9/\3\2\2\2\u02aa\u02a8\3\2\2\2\u02ab\u02ac\5(\25\2\u02ac",
    "\61\3\2\2\2\u02ad\u02af\5\64\33\2\u02ae\u02b0\5:\36\2\u02af\u02ae\3",
    "\2\2\2\u02af\u02b0\3\2\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b2\7Y\2\2\u02b2",
    "\u02b5\3\2\2\2\u02b3\u02b5\5\u008eH\2\u02b4\u02ad\3\2\2\2\u02b4\u02b3",
    "\3\2\2\2\u02b5\63\3\2\2\2\u02b6\u02b8\58\35\2\u02b7\u02b6\3\2\2\2\u02b8",
    "\u02b9\3\2\2\2\u02b9\u02b7\3\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\65\3\2",
    "\2\2\u02bb\u02bd\58\35\2\u02bc\u02bb\3\2\2\2\u02bd\u02be\3\2\2\2\u02be",
    "\u02bc\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\67\3\2\2\2\u02c0\u02c6\5> ",
    "\2\u02c1\u02c6\5@!\2\u02c2\u02c6\5\\/\2\u02c3\u02c6\5^\60\2\u02c4\u02c6",
    "\5`\61\2\u02c5\u02c0\3\2\2\2\u02c5\u02c1\3\2\2\2\u02c5\u02c2\3\2\2\2",
    "\u02c5\u02c3\3\2\2\2\u02c5\u02c4\3\2\2\2\u02c69\3\2\2\2\u02c7\u02c8",
    "\b\36\1\2\u02c8\u02c9\5<\37\2\u02c9\u02cf\3\2\2\2\u02ca\u02cb\f\3\2",
    "\2\u02cb\u02cc\7Z\2\2\u02cc\u02ce\5<\37\2\u02cd\u02ca\3\2\2\2\u02ce",
    "\u02d1\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0;\3\2\2",
    "\2\u02d1\u02cf\3\2\2\2\u02d2\u02d8\5b\62\2\u02d3\u02d4\5b\62\2\u02d4",
    "\u02d5\7[\2\2\u02d5\u02d6\5\u0084C\2\u02d6\u02d8\3\2\2\2\u02d7\u02d2",
    "\3\2\2\2\u02d7\u02d3\3\2\2\2\u02d8=\3\2\2\2\u02d9\u02da\t\4\2\2\u02da",
    "?\3\2\2\2\u02db\u02ea\t\5\2\2\u02dc\u02dd\7\3\2\2\u02dd\u02de\7=\2\2",
    "\u02de\u02df\t\6\2\2\u02df\u02ea\7>\2\2\u02e0\u02ea\5Z.\2\u02e1\u02ea",
    "\5B\"\2\u02e2\u02ea\5R*\2\u02e3\u02ea\5\u0082B\2\u02e4\u02e5\7\t\2\2",
    "\u02e5\u02e6\7=\2\2\u02e6\u02e7\5\60\31\2\u02e7\u02e8\7>\2\2\u02e8\u02ea",
    "\3\2\2\2\u02e9\u02db\3\2\2\2\u02e9\u02dc\3\2\2\2\u02e9\u02e0\3\2\2\2",
    "\u02e9\u02e1\3\2\2\2\u02e9\u02e2\3\2\2\2\u02e9\u02e3\3\2\2\2\u02e9\u02e4",
    "\3\2\2\2\u02eaA\3\2\2\2\u02eb\u02ed\5D#\2\u02ec\u02ee\7k\2\2\u02ed\u02ec",
    "\3\2\2\2\u02ed\u02ee\3\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u02f0\5F$\2\u02f0",
    "\u02f5\3\2\2\2\u02f1\u02f2\5D#\2\u02f2\u02f3\7k\2\2\u02f3\u02f5\3\2",
    "\2\2\u02f4\u02eb\3\2\2\2\u02f4\u02f1\3\2\2\2\u02f5C\3\2\2\2\u02f6\u02f7",
    "\t\7\2\2\u02f7E\3\2\2\2\u02f8\u02f9\7A\2\2\u02f9\u02fa\5H%\2\u02fa\u02fb",
    "\7B\2\2\u02fbG\3\2\2\2\u02fc\u02fd\b%\1\2\u02fd\u02fe\5J&\2\u02fe\u0303",
    "\3\2\2\2\u02ff\u0300\f\3\2\2\u0300\u0302\5J&\2\u0301\u02ff\3\2\2\2\u0302",
    "\u0305\3\2\2\2\u0303\u0301\3\2\2\2\u0303\u0304\3\2\2\2\u0304I\3\2\2",
    "\2\u0305\u0303\3\2\2\2\u0306\u0308\5L\'\2\u0307\u0309\5N(\2\u0308\u0307",
    "\3\2\2\2\u0308\u0309\3\2\2\2\u0309\u030a\3\2\2\2\u030a\u030b\7Y\2\2",
    "\u030b\u030e\3\2\2\2\u030c\u030e\5\u008eH\2\u030d\u0306\3\2\2\2\u030d",
    "\u030c\3\2\2\2\u030eK\3\2\2\2\u030f\u0311\5@!\2\u0310\u0312\5L\'\2\u0311",
    "\u0310\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0318\3\2\2\2\u0313\u0315\5",
    "\\/\2\u0314\u0316\5L\'\2\u0315\u0314\3\2\2\2\u0315\u0316\3\2\2\2\u0316",
    "\u0318\3\2\2\2\u0317\u030f\3\2\2\2\u0317\u0313\3\2\2\2\u0318M\3\2\2",
    "\2\u0319\u031a\b(\1\2\u031a\u031b\5P)\2\u031b\u0321\3\2\2\2\u031c\u031d",
    "\f\3\2\2\u031d\u031e\7Z\2\2\u031e\u0320\5P)\2\u031f\u031c\3\2\2\2\u0320",
    "\u0323\3\2\2\2\u0321\u031f\3\2\2\2\u0321\u0322\3\2\2\2\u0322O\3\2\2",
    "\2\u0323\u0321\3\2\2\2\u0324\u032b\5b\62\2\u0325\u0327\5b\62\2\u0326",
    "\u0325\3\2\2\2\u0326\u0327\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329\7",
    "X\2\2\u0329\u032b\5\60\31\2\u032a\u0324\3\2\2\2\u032a\u0326\3\2\2\2",
    "\u032bQ\3\2\2\2\u032c\u032e\7\33\2\2\u032d\u032f\7k\2\2\u032e\u032d",
    "\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0331\7A\2\2",
    "\u0331\u0332\5T+\2\u0332\u0333\7B\2\2\u0333\u0340\3\2\2\2\u0334\u0336",
    "\7\33\2\2\u0335\u0337\7k\2\2\u0336\u0335\3\2\2\2\u0336\u0337\3\2\2\2",
    "\u0337\u0338\3\2\2\2\u0338\u0339\7A\2\2\u0339\u033a\5T+\2\u033a\u033b",
    "\7Z\2\2\u033b\u033c\7B\2\2\u033c\u0340\3\2\2\2\u033d\u033e\7\33\2\2",
    "\u033e\u0340\7k\2\2\u033f\u032c\3\2\2\2\u033f\u0334\3\2\2\2\u033f\u033d",
    "\3\2\2\2\u0340S\3\2\2\2\u0341\u0342\b+\1\2\u0342\u0343\5V,\2\u0343\u0349",
    "\3\2\2\2\u0344\u0345\f\3\2\2\u0345\u0346\7Z\2\2\u0346\u0348\5V,\2\u0347",
    "\u0344\3\2\2\2\u0348\u034b\3\2\2\2\u0349\u0347\3\2\2\2\u0349\u034a\3",
    "\2\2\2\u034aU\3\2\2\2\u034b\u0349\3\2\2\2\u034c\u0352\5X-\2\u034d\u034e",
    "\5X-\2\u034e\u034f\7[\2\2\u034f\u0350\5\60\31\2\u0350\u0352\3\2\2\2",
    "\u0351\u034c\3\2\2\2\u0351\u034d\3\2\2\2\u0352W\3\2\2\2\u0353\u0354",
    "\7k\2\2\u0354Y\3\2\2\2\u0355\u0356\7\65\2\2\u0356\u0357\7=\2\2\u0357",
    "\u0358\5|?\2\u0358\u0359\7>\2\2\u0359[\3\2\2\2\u035a\u035b\t\b\2\2\u035b",
    "]\3\2\2\2\u035c\u0363\t\t\2\2\u035d\u0363\5h\65\2\u035e\u035f\7\f\2",
    "\2\u035f\u0360\7=\2\2\u0360\u0361\7k\2\2\u0361\u0363\7>\2\2\u0362\u035c",
    "\3\2\2\2\u0362\u035d\3\2\2\2\u0362\u035e\3\2\2\2\u0363_\3\2\2\2\u0364",
    "\u0365\7\63\2\2\u0365\u0366\7=\2\2\u0366\u0367\5|?\2\u0367\u0368\7>",
    "\2\2\u0368\u036f\3\2\2\2\u0369\u036a\7\63\2\2\u036a\u036b\7=\2\2\u036b",
    "\u036c\5\60\31\2\u036c\u036d\7>\2\2\u036d\u036f\3\2\2\2\u036e\u0364",
    "\3\2\2\2\u036e\u0369\3\2\2\2\u036fa\3\2\2\2\u0370\u0372\5p9\2\u0371",
    "\u0370\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0377\5",
    "d\63\2\u0374\u0376\5f\64\2\u0375\u0374\3\2\2\2\u0376\u0379\3\2\2\2\u0377",
    "\u0375\3\2\2\2\u0377\u0378\3\2\2\2\u0378c\3\2\2\2\u0379\u0377\3\2\2",
    "\2\u037a\u037b\b\63\1\2\u037b\u0381\7k\2\2\u037c\u037d\7=\2\2\u037d",
    "\u037e\5b\62\2\u037e\u037f\7>\2\2\u037f\u0381\3\2\2\2\u0380\u037a\3",
    "\2\2\2\u0380\u037c\3\2\2\2\u0381\u03af\3\2\2\2\u0382\u0383\f\b\2\2\u0383",
    "\u0385\7?\2\2\u0384\u0386\5r:\2\u0385\u0384\3\2\2\2\u0385\u0386\3\2",
    "\2\2\u0386\u0388\3\2\2\2\u0387\u0389\5*\26\2\u0388\u0387\3\2\2\2\u0388",
    "\u0389\3\2\2\2\u0389\u038a\3\2\2\2\u038a\u03ae\7@\2\2\u038b\u038c\f",
    "\7\2\2\u038c\u038d\7?\2\2\u038d\u038f\7*\2\2\u038e\u0390\5r:\2\u038f",
    "\u038e\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0391\3\2\2\2\u0391\u0392\5",
    "*\26\2\u0392\u0393\7@\2\2\u0393\u03ae\3\2\2\2\u0394\u0395\f\6\2\2\u0395",
    "\u0396\7?\2\2\u0396\u0397\5r:\2\u0397\u0398\7*\2\2\u0398\u0399\5*\26",
    "\2\u0399\u039a\7@\2\2\u039a\u03ae\3\2\2\2\u039b\u039c\f\5\2\2\u039c",
    "\u039e\7?\2\2\u039d\u039f\5r:\2\u039e\u039d\3\2\2\2\u039e\u039f\3\2",
    "\2\2\u039f\u03a0\3\2\2\2\u03a0\u03a1\7M\2\2\u03a1\u03ae\7@\2\2\u03a2",
    "\u03a3\f\4\2\2\u03a3\u03a4\7=\2\2\u03a4\u03a5\5t;\2\u03a5\u03a6\7>\2",
    "\2\u03a6\u03ae\3\2\2\2\u03a7\u03a8\f\3\2\2\u03a8\u03aa\7=\2\2\u03a9",
    "\u03ab\5z>\2\u03aa\u03a9\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u03ac\3\2",
    "\2\2\u03ac\u03ae\7>\2\2\u03ad\u0382\3\2\2\2\u03ad\u038b\3\2\2\2\u03ad",
    "\u0394\3\2\2\2\u03ad\u039b\3\2\2\2\u03ad\u03a2\3\2\2\2\u03ad\u03a7\3",
    "\2\2\2\u03ae\u03b1\3\2\2\2\u03af\u03ad\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0",
    "e\3\2\2\2\u03b1\u03af\3\2\2\2\u03b2\u03b3\7\r\2\2\u03b3\u03b5\7=\2\2",
    "\u03b4\u03b6\7m\2\2\u03b5\u03b4\3\2\2\2\u03b6\u03b7\3\2\2\2\u03b7\u03b5",
    "\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03bc\7>\2\2",
    "\u03ba\u03bc\5h\65\2\u03bb\u03b2\3\2\2\2\u03bb\u03ba\3\2\2\2\u03bcg",
    "\3\2\2\2\u03bd\u03be\7\16\2\2\u03be\u03bf\7=\2\2\u03bf\u03c0\7=\2\2",
    "\u03c0\u03c1\5j\66\2\u03c1\u03c2\7>\2\2\u03c2\u03c3\7>\2\2\u03c3i\3",
    "\2\2\2\u03c4\u03c9\5l\67\2\u03c5\u03c6\7Z\2\2\u03c6\u03c8\5l\67\2\u03c7",
    "\u03c5\3\2\2\2\u03c8\u03cb\3\2\2\2\u03c9\u03c7\3\2\2\2\u03c9\u03ca\3",
    "\2\2\2\u03ca\u03ce\3\2\2\2\u03cb\u03c9\3\2\2\2\u03cc\u03ce\3\2\2\2\u03cd",
    "\u03c4\3\2\2\2\u03cd\u03cc\3\2\2\2\u03cek\3\2\2\2\u03cf\u03d5\n\n\2",
    "\2\u03d0\u03d2\7=\2\2\u03d1\u03d3\5\f\7\2\u03d2\u03d1\3\2\2\2\u03d2",
    "\u03d3\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4\u03d6\7>\2\2\u03d5\u03d0\3",
    "\2\2\2\u03d5\u03d6\3\2\2\2\u03d6\u03d9\3\2\2\2\u03d7\u03d9\3\2\2\2\u03d8",
    "\u03cf\3\2\2\2\u03d8\u03d7\3\2\2\2\u03d9m\3\2\2\2\u03da\u03e0\n\13\2",
    "\2\u03db\u03dc\7=\2\2\u03dc\u03dd\5n8\2\u03dd\u03de\7>\2\2\u03de\u03e0",
    "\3\2\2\2\u03df\u03da\3\2\2\2\u03df\u03db\3\2\2\2\u03e0\u03e3\3\2\2\2",
    "\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2\2\2\u03e2o\3\2\2\2\u03e3\u03e1",
    "\3\2\2\2\u03e4\u03e6\7M\2\2\u03e5\u03e7\5r:\2\u03e6\u03e5\3\2\2\2\u03e6",
    "\u03e7\3\2\2\2\u03e7\u03f7\3\2\2\2\u03e8\u03ea\7M\2\2\u03e9\u03eb\5",
    "r:\2\u03ea\u03e9\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec",
    "\u03f7\5p9\2\u03ed\u03ef\7T\2\2\u03ee\u03f0\5r:\2\u03ef\u03ee\3\2\2",
    "\2\u03ef\u03f0\3\2\2\2\u03f0\u03f7\3\2\2\2\u03f1\u03f3\7T\2\2\u03f2",
    "\u03f4\5r:\2\u03f3\u03f2\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f5\3\2",
    "\2\2\u03f5\u03f7\5p9\2\u03f6\u03e4\3\2\2\2\u03f6\u03e8\3\2\2\2\u03f6",
    "\u03ed\3\2\2\2\u03f6\u03f1\3\2\2\2\u03f7q\3\2\2\2\u03f8\u03f9\b:\1\2",
    "\u03f9\u03fa\5\\/\2\u03fa\u03ff\3\2\2\2\u03fb\u03fc\f\3\2\2\u03fc\u03fe",
    "\5\\/\2\u03fd\u03fb\3\2\2\2\u03fe\u0401\3\2\2\2\u03ff\u03fd\3\2\2\2",
    "\u03ff\u0400\3\2\2\2\u0400s\3\2\2\2\u0401\u03ff\3\2\2\2\u0402\u0408",
    "\5v<\2\u0403\u0404\5v<\2\u0404\u0405\7Z\2\2\u0405\u0406\7j\2\2\u0406",
    "\u0408\3\2\2\2\u0407\u0402\3\2\2\2\u0407\u0403\3\2\2\2\u0408u\3\2\2",
    "\2\u0409\u040a\b<\1\2\u040a\u040b\5x=\2\u040b\u0411\3\2\2\2\u040c\u040d",
    "\f\3\2\2\u040d\u040e\7Z\2\2\u040e\u0410\5x=\2\u040f\u040c\3\2\2\2\u0410",
    "\u0413\3\2\2\2\u0411\u040f\3\2\2\2\u0411\u0412\3\2\2\2\u0412w\3\2\2",
    "\2\u0413\u0411\3\2\2\2\u0414\u0415\5\64\33\2\u0415\u0416\5b\62\2\u0416",
    "\u041c\3\2\2\2\u0417\u0419\5\66\34\2\u0418\u041a\5~@\2\u0419\u0418\3",
    "\2\2\2\u0419\u041a\3\2\2\2\u041a\u041c\3\2\2\2\u041b\u0414\3\2\2\2\u041b",
    "\u0417\3\2\2\2\u041cy\3\2\2\2\u041d\u041e\b>\1\2\u041e\u041f\7k\2\2",
    "\u041f\u0425\3\2\2\2\u0420\u0421\f\3\2\2\u0421\u0422\7Z\2\2\u0422\u0424",
    "\7k\2\2\u0423\u0420\3\2\2\2\u0424\u0427\3\2\2\2\u0425\u0423\3\2\2\2",
    "\u0425\u0426\3\2\2\2\u0426{\3\2\2\2\u0427\u0425\3\2\2\2\u0428\u042a",
    "\5L\'\2\u0429\u042b\5~@\2\u042a\u0429\3\2\2\2\u042a\u042b\3\2\2\2\u042b",
    "}\3\2\2\2\u042c\u0438\5p9\2\u042d\u042f\5p9\2\u042e\u042d\3\2\2\2\u042e",
    "\u042f\3\2\2\2\u042f\u0430\3\2\2\2\u0430\u0434\5\u0080A\2\u0431\u0433",
    "\5f\64\2\u0432\u0431\3\2\2\2\u0433\u0436\3\2\2\2\u0434\u0432\3\2\2\2",
    "\u0434\u0435\3\2\2\2\u0435\u0438\3\2\2\2\u0436\u0434\3\2\2\2\u0437\u042c",
    "\3\2\2\2\u0437\u042e\3\2\2\2\u0438\177\3\2\2\2\u0439\u043a\bA\1\2\u043a",
    "\u043b\7=\2\2\u043b\u043c\5~@\2\u043c\u0440\7>\2\2\u043d\u043f\5f\64",
    "\2\u043e\u043d\3\2\2\2\u043f\u0442\3\2\2\2\u0440\u043e\3\2\2\2\u0440",
    "\u0441\3\2\2\2\u0441\u0468\3\2\2\2\u0442\u0440\3\2\2\2\u0443\u0445\7",
    "?\2\2\u0444\u0446\5r:\2\u0445\u0444\3\2\2\2\u0445\u0446\3\2\2\2\u0446",
    "\u0448\3\2\2\2\u0447\u0449\5*\26\2\u0448\u0447\3\2\2\2\u0448\u0449\3",
    "\2\2\2\u0449\u044a\3\2\2\2\u044a\u0468\7@\2\2\u044b\u044c\7?\2\2\u044c",
    "\u044e\7*\2\2\u044d\u044f\5r:\2\u044e\u044d\3\2\2\2\u044e\u044f\3\2",
    "\2\2\u044f\u0450\3\2\2\2\u0450\u0451\5*\26\2\u0451\u0452\7@\2\2\u0452",
    "\u0468\3\2\2\2\u0453\u0454\7?\2\2\u0454\u0455\5r:\2\u0455\u0456\7*\2",
    "\2\u0456\u0457\5*\26\2\u0457\u0458\7@\2\2\u0458\u0468\3\2\2\2\u0459",
    "\u045a\7?\2\2\u045a\u045b\7M\2\2\u045b\u0468\7@\2\2\u045c\u045e\7=\2",
    "\2\u045d\u045f\5t;\2\u045e\u045d\3\2\2\2\u045e\u045f\3\2\2\2\u045f\u0460",
    "\3\2\2\2\u0460\u0464\7>\2\2\u0461\u0463\5f\64\2\u0462\u0461\3\2\2\2",
    "\u0463\u0466\3\2\2\2\u0464\u0462\3\2\2\2\u0464\u0465\3\2\2\2\u0465\u0468",
    "\3\2\2\2\u0466\u0464\3\2\2\2\u0467\u0439\3\2\2\2\u0467\u0443\3\2\2\2",
    "\u0467\u044b\3\2\2\2\u0467\u0453\3\2\2\2\u0467\u0459\3\2\2\2\u0467\u045c",
    "\3\2\2\2\u0468\u0494\3\2\2\2\u0469\u046a\f\7\2\2\u046a\u046c\7?\2\2",
    "\u046b\u046d\5r:\2\u046c\u046b\3\2\2\2\u046c\u046d\3\2\2\2\u046d\u046f",
    "\3\2\2\2\u046e\u0470\5*\26\2\u046f\u046e\3\2\2\2\u046f\u0470\3\2\2\2",
    "\u0470\u0471\3\2\2\2\u0471\u0493\7@\2\2\u0472\u0473\f\6\2\2\u0473\u0474",
    "\7?\2\2\u0474\u0476\7*\2\2\u0475\u0477\5r:\2\u0476\u0475\3\2\2\2\u0476",
    "\u0477\3\2\2\2\u0477\u0478\3\2\2\2\u0478\u0479\5*\26\2\u0479\u047a\7",
    "@\2\2\u047a\u0493\3\2\2\2\u047b\u047c\f\5\2\2\u047c\u047d\7?\2\2\u047d",
    "\u047e\5r:\2\u047e\u047f\7*\2\2\u047f\u0480\5*\26\2\u0480\u0481\7@\2",
    "\2\u0481\u0493\3\2\2\2\u0482\u0483\f\4\2\2\u0483\u0484\7?\2\2\u0484",
    "\u0485\7M\2\2\u0485\u0493\7@\2\2\u0486\u0487\f\3\2\2\u0487\u0489\7=",
    "\2\2\u0488\u048a\5t;\2\u0489\u0488\3\2\2\2\u0489\u048a\3\2\2\2\u048a",
    "\u048b\3\2\2\2\u048b\u048f\7>\2\2\u048c\u048e\5f\64\2\u048d\u048c\3",
    "\2\2\2\u048e\u0491\3\2\2\2\u048f\u048d\3\2\2\2\u048f\u0490\3\2\2\2\u0490",
    "\u0493\3\2\2\2\u0491\u048f\3\2\2\2\u0492\u0469\3\2\2\2\u0492\u0472\3",
    "\2\2\2\u0492\u047b\3\2\2\2\u0492\u0482\3\2\2\2\u0492\u0486\3\2\2\2\u0493",
    "\u0496\3\2\2\2\u0494\u0492\3\2\2\2\u0494\u0495\3\2\2\2\u0495\u0081\3",
    "\2\2\2\u0496\u0494\3\2\2\2\u0497\u0498\7k\2\2\u0498\u0083\3\2\2\2\u0499",
    "\u04a4\5*\26\2\u049a\u049b\7A\2\2\u049b\u049c\5\u0086D\2\u049c\u049d",
    "\7B\2\2\u049d\u04a4\3\2\2\2\u049e\u049f\7A\2\2\u049f\u04a0\5\u0086D",
    "\2\u04a0\u04a1\7Z\2\2\u04a1\u04a2\7B\2\2\u04a2\u04a4\3\2\2\2\u04a3\u0499",
    "\3\2\2\2\u04a3\u049a\3\2\2\2\u04a3\u049e\3\2\2\2\u04a4\u0085\3\2\2\2",
    "\u04a5\u04a7\bD\1\2\u04a6\u04a8\5\u0088E\2\u04a7\u04a6\3\2\2\2\u04a7",
    "\u04a8\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9\u04aa\5\u0084C\2\u04aa\u04b3",
    "\3\2\2\2\u04ab\u04ac\f\3\2\2\u04ac\u04ae\7Z\2\2\u04ad\u04af\5\u0088",
    "E\2\u04ae\u04ad\3\2\2\2\u04ae\u04af\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0",
    "\u04b2\5\u0084C\2\u04b1\u04ab\3\2\2\2\u04b2\u04b5\3\2\2\2\u04b3\u04b1",
    "\3\2\2\2\u04b3\u04b4\3\2\2\2\u04b4\u0087\3\2\2\2\u04b5\u04b3\3\2\2\2",
    "\u04b6\u04b7\5\u008aF\2\u04b7\u04b8\7[\2\2\u04b8\u0089\3\2\2\2\u04b9",
    "\u04ba\bF\1\2\u04ba\u04bb\5\u008cG\2\u04bb\u04c0\3\2\2\2\u04bc\u04bd",
    "\f\3\2\2\u04bd\u04bf\5\u008cG\2\u04be\u04bc\3\2\2\2\u04bf\u04c2\3\2",
    "\2\2\u04c0\u04be\3\2\2\2\u04c0\u04c1\3\2\2\2\u04c1\u008b\3\2\2\2\u04c2",
    "\u04c0\3\2\2\2\u04c3\u04c4\7?\2\2\u04c4\u04c5\5\60\31\2\u04c5\u04c6",
    "\7@\2\2\u04c6\u04ca\3\2\2\2\u04c7\u04c8\7i\2\2\u04c8\u04ca\7k\2\2\u04c9",
    "\u04c3\3\2\2\2\u04c9\u04c7\3\2\2\2\u04ca\u008d\3\2\2\2\u04cb\u04cc\7",
    ";\2\2\u04cc\u04cd\7=\2\2\u04cd\u04ce\5\60\31\2\u04ce\u04d0\7Z\2\2\u04cf",
    "\u04d1\7m\2\2\u04d0\u04cf\3\2\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d0\3",
    "\2\2\2\u04d2\u04d3\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04d5\7>\2\2\u04d5",
    "\u04d6\7Y\2\2\u04d6\u008f\3\2\2\2\u04d7\u04fd\5\u0092J\2\u04d8\u04fd",
    "\5\u0094K\2\u04d9\u04fd\5\u009cO\2\u04da\u04fd\5\u009eP\2\u04db\u04fd",
    "\5\u00a0Q\2\u04dc\u04fd\5\u00a2R\2\u04dd\u04de\t\f\2\2\u04de\u04df\t",
    "\r\2\2\u04df\u04e8\7=\2\2\u04e0\u04e5\5&\24\2\u04e1\u04e2\7Z\2\2\u04e2",
    "\u04e4\5&\24\2\u04e3\u04e1\3\2\2\2\u04e4\u04e7\3\2\2\2\u04e5\u04e3\3",
    "\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u04e9\3\2\2\2\u04e7\u04e5\3\2\2\2\u04e8",
    "\u04e0\3\2\2\2\u04e8\u04e9\3\2\2\2\u04e9\u04f7\3\2\2\2\u04ea\u04f3\7",
    "X\2\2\u04eb\u04f0\5&\24\2\u04ec\u04ed\7Z\2\2\u04ed\u04ef\5&\24\2\u04ee",
    "\u04ec\3\2\2\2\u04ef\u04f2\3\2\2\2\u04f0\u04ee\3\2\2\2\u04f0\u04f1\3",
    "\2\2\2\u04f1\u04f4\3\2\2\2\u04f2\u04f0\3\2\2\2\u04f3\u04eb\3\2\2\2\u04f3",
    "\u04f4\3\2\2\2\u04f4\u04f6\3\2\2\2\u04f5\u04ea\3\2\2\2\u04f6\u04f9\3",
    "\2\2\2\u04f7\u04f5\3\2\2\2\u04f7\u04f8\3\2\2\2\u04f8\u04fa\3\2\2\2\u04f9",
    "\u04f7\3\2\2\2\u04fa\u04fb\7>\2\2\u04fb\u04fd\7Y\2\2\u04fc\u04d7\3\2",
    "\2\2\u04fc\u04d8\3\2\2\2\u04fc\u04d9\3\2\2\2\u04fc\u04da\3\2\2\2\u04fc",
    "\u04db\3\2\2\2\u04fc\u04dc\3\2\2\2\u04fc\u04dd\3\2\2\2\u04fd\u0091\3",
    "\2\2\2\u04fe\u04ff\7k\2\2\u04ff\u0500\7X\2\2\u0500\u050a\5\u0090I\2",
    "\u0501\u0502\7\23\2\2\u0502\u0503\5\60\31\2\u0503\u0504\7X\2\2\u0504",
    "\u0505\5\u0090I\2\u0505\u050a\3\2\2\2\u0506\u0507\7\27\2\2\u0507\u0508",
    "\7X\2\2\u0508\u050a\5\u0090I\2\u0509\u04fe\3\2\2\2\u0509\u0501\3\2\2",
    "\2\u0509\u0506\3\2\2\2\u050a\u0093\3\2\2\2\u050b\u050d\7A\2\2\u050c",
    "\u050e\5\u0096L\2\u050d\u050c\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u050f",
    "\3\2\2\2\u050f\u0510\7B\2\2\u0510\u0095\3\2\2\2\u0511\u0512\bL\1\2\u0512",
    "\u0513\5\u0098M\2\u0513\u0518\3\2\2\2\u0514\u0515\f\3\2\2\u0515\u0517",
    "\5\u0098M\2\u0516\u0514\3\2\2\2\u0517\u051a\3\2\2\2\u0518\u0516\3\2",
    "\2\2\u0518\u0519\3\2\2\2\u0519\u0097\3\2\2\2\u051a\u0518\3\2\2\2\u051b",
    "\u051f\5\u009aN\2\u051c\u051f\5\62\32\2\u051d\u051f\5\u0090I\2\u051e",
    "\u051b\3\2\2\2\u051e\u051c\3\2\2\2\u051e\u051d\3\2\2\2\u051f\u0099\3",
    "\2\2\2\u0520\u0521\7k\2\2\u0521\u0522\7=\2\2\u0522\u0523\5*\26\2\u0523",
    "\u0524\7>\2\2\u0524\u0525\7Y\2\2\u0525\u009b\3\2\2\2\u0526\u0528\5.",
    "\30\2\u0527\u0526\3\2\2\2\u0527\u0528\3\2\2\2\u0528\u0529\3\2\2\2\u0529",
    "\u052a\7Y\2\2\u052a\u009d\3\2\2\2\u052b\u052c\7 \2\2\u052c\u052d\7=",
    "\2\2\u052d\u052e\5.\30\2\u052e\u052f\7>\2\2\u052f\u0532\5\u0090I\2\u0530",
    "\u0531\7\32\2\2\u0531\u0533\5\u0090I\2\u0532\u0530\3\2\2\2\u0532\u0533",
    "\3\2\2\2\u0533\u053b\3\2\2\2\u0534\u0535\7,\2\2\u0535\u0536\7=\2\2\u0536",
    "\u0537\5.\30\2\u0537\u0538\7>\2\2\u0538\u0539\5\u0090I\2\u0539\u053b",
    "\3\2\2\2\u053a\u052b\3\2\2\2\u053a\u0534\3\2\2\2\u053b\u009f\3\2\2\2",
    "\u053c\u053d\7\62\2\2\u053d\u053e\7=\2\2\u053e\u053f\5.\30\2\u053f\u0540",
    "\7>\2\2\u0540\u0541\5\u0090I\2\u0541\u0567\3\2\2\2\u0542\u0543\7\30",
    "\2\2\u0543\u0544\5\u0090I\2\u0544\u0545\7\62\2\2\u0545\u0546\7=\2\2",
    "\u0546\u0547\5.\30\2\u0547\u0548\7>\2\2\u0548\u0549\7Y\2\2\u0549\u0567",
    "\3\2\2\2\u054a\u054b\7\36\2\2\u054b\u054d\7=\2\2\u054c\u054e\5.\30\2",
    "\u054d\u054c\3\2\2\2\u054d\u054e\3\2\2\2\u054e\u054f\3\2\2\2\u054f\u0551",
    "\7Y\2\2\u0550\u0552\5.\30\2\u0551\u0550\3\2\2\2\u0551\u0552\3\2\2\2",
    "\u0552\u0553\3\2\2\2\u0553\u0555\7Y\2\2\u0554\u0556\5.\30\2\u0555\u0554",
    "\3\2\2\2\u0555\u0556\3\2\2\2\u0556\u0557\3\2\2\2\u0557\u0558\7>\2\2",
    "\u0558\u0567\5\u0090I\2\u0559\u055a\7\36\2\2\u055a\u055b\7=\2\2\u055b",
    "\u055d\5\62\32\2\u055c\u055e\5.\30\2\u055d\u055c\3\2\2\2\u055d\u055e",
    "\3\2\2\2\u055e\u055f\3\2\2\2\u055f\u0561\7Y\2\2\u0560\u0562\5.\30\2",
    "\u0561\u0560\3\2\2\2\u0561\u0562\3\2\2\2\u0562\u0563\3\2\2\2\u0563\u0564",
    "\7>\2\2\u0564\u0565\5\u0090I\2\u0565\u0567\3\2\2\2\u0566\u053c\3\2\2",
    "\2\u0566\u0542\3\2\2\2\u0566\u054a\3\2\2\2\u0566\u0559\3\2\2\2\u0567",
    "\u00a1\3\2\2\2\u0568\u0569\7\37\2\2\u0569\u056a\7k\2\2\u056a\u0579\7",
    "Y\2\2\u056b\u056c\7\26\2\2\u056c\u0579\7Y\2\2\u056d\u056e\7\22\2\2\u056e",
    "\u0579\7Y\2\2\u056f\u0571\7&\2\2\u0570\u0572\5.\30\2\u0571\u0570\3\2",
    "\2\2\u0571\u0572\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0579\7Y\2\2\u0574",
    "\u0575\7\37\2\2\u0575\u0576\5\16\b\2\u0576\u0577\7Y\2\2\u0577\u0579",
    "\3\2\2\2\u0578\u0568\3\2\2\2\u0578\u056b\3\2\2\2\u0578\u056d\3\2\2\2",
    "\u0578\u056f\3\2\2\2\u0578\u0574\3\2\2\2\u0579\u00a3\3\2\2\2\u057a\u057c",
    "\5\u00a6T\2\u057b\u057a\3\2\2\2\u057b\u057c\3\2\2\2\u057c\u057d\3\2",
    "\2\2\u057d\u0580\7\2\2\3\u057e\u0580\7\2\2\3\u057f\u057b\3\2\2\2\u057f",
    "\u057e\3\2\2\2\u0580\u00a5\3\2\2\2\u0581\u0582\bT\1\2\u0582\u0583\5",
    "\u00a8U\2\u0583\u0588\3\2\2\2\u0584\u0585\f\3\2\2\u0585\u0587\5\u00a8",
    "U\2\u0586\u0584\3\2\2\2\u0587\u058a\3\2\2\2\u0588\u0586\3\2\2\2\u0588",
    "\u0589\3\2\2\2\u0589\u00a7\3\2\2\2\u058a\u0588\3\2\2\2\u058b\u058f\5",
    "\u00aaV\2\u058c\u058f\5\62\32\2\u058d\u058f\7Y\2\2\u058e\u058b\3\2\2",
    "\2\u058e\u058c\3\2\2\2\u058e\u058d\3\2\2\2\u058f\u00a9\3\2\2\2\u0590",
    "\u0592\5\64\33\2\u0591\u0590\3\2\2\2\u0591\u0592\3\2\2\2\u0592\u0593",
    "\3\2\2\2\u0593\u0595\5b\62\2\u0594\u0596\5\u00acW\2\u0595\u0594\3\2",
    "\2\2\u0595\u0596\3\2\2\2\u0596\u0597\3\2\2\2\u0597\u0598\5\u0094K\2",
    "\u0598\u00ab\3\2\2\2\u0599\u059a\bW\1\2\u059a\u059b\5\62\32\2\u059b",
    "\u05a0\3\2\2\2\u059c\u059d\f\3\2\2\u059d\u059f\5\62\32\2\u059e\u059c",
    "\3\2\2\2\u059f\u05a2\3\2\2\2\u05a0\u059e\3\2\2\2\u05a0\u05a1\3\2\2\2",
    "\u05a1\u00ad\3\2\2\2\u05a2\u05a0\3\2\2\2\u05a3\u05a4\7k\2\2\u05a4\u05cd",
    "\7\2\2\3\u05a5\u05a6\7l\2\2\u05a6\u05cd\7\2\2\3\u05a7\u05a9\7m\2\2\u05a8",
    "\u05a7\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05a8\3\2\2\2\u05aa\u05ab\3",
    "\2\2\2\u05ab\u05ac\3\2\2\2\u05ac\u05cd\7\2\2\3\u05ad\u05ae\7=\2\2\u05ae",
    "\u05af\5.\30\2\u05af\u05b0\7>\2\2\u05b0\u05b1\7\2\2\3\u05b1\u05cd\3",
    "\2\2\2\u05b2\u05b3\5\4\3\2\u05b3\u05b4\7\2\2\3\u05b4\u05cd\3\2\2\2\u05b5",
    "\u05b7\7\3\2\2\u05b6\u05b5\3\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u05b8\3",
    "\2\2\2\u05b8\u05b9\7=\2\2\u05b9\u05ba\5\u0094K\2\u05ba\u05bb\7>\2\2",
    "\u05bb\u05cd\3\2\2\2\u05bc\u05bd\7\4\2\2\u05bd\u05be\7=\2\2\u05be\u05bf",
    "\5\16\b\2\u05bf\u05c0\7Z\2\2\u05c0\u05c1\5|?\2\u05c1\u05c2\7>\2\2\u05c2",
    "\u05c3\7\2\2\3\u05c3\u05cd\3\2\2\2\u05c4\u05c5\7\5\2\2\u05c5\u05c6\7",
    "=\2\2\u05c6\u05c7\5|?\2\u05c7\u05c8\7Z\2\2\u05c8\u05c9\5\16\b\2\u05c9",
    "\u05ca\7>\2\2\u05ca\u05cb\7\2\2\3\u05cb\u05cd\3\2\2\2\u05cc\u05a3\3",
    "\2\2\2\u05cc\u05a5\3\2\2\2\u05cc\u05a8\3\2\2\2\u05cc\u05ad\3\2\2\2\u05cc",
    "\u05b2\3\2\2\2\u05cc\u05b6\3\2\2\2\u05cc\u05bc\3\2\2\2\u05cc\u05c4\3",
    "\2\2\2\u05cd\u00af\3\2\2\2\u05ce\u05cf\78\2\2\u05cf\u05d0\7=\2\2\u05d0",
    "\u05d1\5*\26\2\u05d1\u05d2\7Z\2\2\u05d2\u05d3\5\6\4\2\u05d3\u05d4\7",
    ">\2\2\u05d4\u05d5\7\2\2\3\u05d5\u00b1\3\2\2\2\u05d6\u05d7\5\b\5\2\u05d7",
    "\u05d8\7\2\2\3\u05d8\u05df\3\2\2\2\u05d9\u05da\5\6\4\2\u05da\u05db\7",
    "Z\2\2\u05db\u05dc\5\b\5\2\u05dc\u05dd\7\2\2\3\u05dd\u05df\3\2\2\2\u05de",
    "\u05d6\3\2\2\2\u05de\u05d9\3\2\2\2\u05df\u00b3\3\2\2\2\u05e0\u05e1\5",
    "|?\2\u05e1\u05e2\7X\2\2\u05e2\u05e3\5*\26\2\u05e3\u05e4\7\2\2\3\u05e4",
    "\u05eb\3\2\2\2\u05e5\u05e6\7\27\2\2\u05e6\u05e7\7X\2\2\u05e7\u05e8\5",
    "*\26\2\u05e8\u05e9\7\2\2\3\u05e9\u05eb\3\2\2\2\u05ea\u05e0\3\2\2\2\u05ea",
    "\u05e5\3\2\2\2\u05eb\u00b5\3\2\2\2\u05ec\u05ed\5\2\2\2\u05ed\u05ee\7",
    "\2\2\3\u05ee\u0634\3\2\2\2\u05ef\u05f0\5\n\6\2\u05f0\u05f1\7?\2\2\u05f1",
    "\u05f2\5.\30\2\u05f2\u05f3\7@\2\2\u05f3\u05f4\7\2\2\3\u05f4\u0634\3",
    "\2\2\2\u05f5\u05f6\5\n\6\2\u05f6\u05f8\7=\2\2\u05f7\u05f9\5\f\7\2\u05f8",
    "\u05f7\3\2\2\2\u05f8\u05f9\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fb\7",
    ">\2\2\u05fb\u05fc\7\2\2\3\u05fc\u0634\3\2\2\2\u05fd\u05fe\5\n\6\2\u05fe",
    "\u05ff\7i\2\2\u05ff\u0600\7k\2\2\u0600\u0601\7\2\2\3\u0601\u0634\3\2",
    "\2\2\u0602\u0603\5\n\6\2\u0603\u0604\7h\2\2\u0604\u0605\7k\2\2\u0605",
    "\u0606\7\2\2\3\u0606\u0634\3\2\2\2\u0607\u0608\5\n\6\2\u0608\u0609\7",
    "J\2\2\u0609\u060a\7\2\2\3\u060a\u0634\3\2\2\2\u060b\u060c\5\n\6\2\u060c",
    "\u060d\7L\2\2\u060d\u060e\7\2\2\3\u060e\u0634\3\2\2\2\u060f\u0610\7",
    "=\2\2\u0610\u0611\5|?\2\u0611\u0612\7>\2\2\u0612\u0613\7A\2\2\u0613",
    "\u0614\5\u0086D\2\u0614\u0615\7B\2\2\u0615\u0616\7\2\2\3\u0616\u0634",
    "\3\2\2\2\u0617\u0618\7=\2\2\u0618\u0619\5|?\2\u0619\u061a\7>\2\2\u061a",
    "\u061b\7A\2\2\u061b\u061c\5\u0086D\2\u061c\u061d\7Z\2\2\u061d\u061e",
    "\7B\2\2\u061e\u061f\7\2\2\3\u061f\u0634\3\2\2\2\u0620\u0621\7\3\2\2",
    "\u0621\u0622\7=\2\2\u0622\u0623\5|?\2\u0623\u0624\7>\2\2\u0624\u0625",
    "\7A\2\2\u0625\u0626\5\u0086D\2\u0626\u0627\7B\2\2\u0627\u0628\7\2\2",
    "\3\u0628\u0634\3\2\2\2\u0629\u062a\7\3\2\2\u062a\u062b\7=\2\2\u062b",
    "\u062c\5|?\2\u062c\u062d\7>\2\2\u062d\u062e\7A\2\2\u062e\u062f\5\u0086",
    "D\2\u062f\u0630\7Z\2\2\u0630\u0631\7B\2\2\u0631\u0632\7\2\2\3\u0632",
    "\u0634\3\2\2\2\u0633\u05ec\3\2\2\2\u0633\u05ef\3\2\2\2\u0633\u05f5\3",
    "\2\2\2\u0633\u05fd\3\2\2\2\u0633\u0602\3\2\2\2\u0633\u0607\3\2\2\2\u0633",
    "\u060b\3\2\2\2\u0633\u060f\3\2\2\2\u0633\u0617\3\2\2\2\u0633\u0620\3",
    "\2\2\2\u0633\u0629\3\2\2\2\u0634\u00b7\3\2\2\2\u0635\u0636\5*\26\2\u0636",
    "\u0637\7\2\2\3\u0637\u063e\3\2\2\2\u0638\u0639\5\f\7\2\u0639\u063a\7",
    "Z\2\2\u063a\u063b\5*\26\2\u063b\u063c\7\2\2\3\u063c\u063e\3\2\2\2\u063d",
    "\u0635\3\2\2\2\u063d\u0638\3\2\2\2\u063e\u00b9\3\2\2\2\u063f\u0640\5",
    "\n\6\2\u0640\u0641\7\2\2\3\u0641\u0661\3\2\2\2\u0642\u0643\7J\2\2\u0643",
    "\u0644\5\16\b\2\u0644\u0645\7\2\2\3\u0645\u0661\3\2\2\2\u0646\u0647",
    "\7L\2\2\u0647\u0648\5\16\b\2\u0648\u0649\7\2\2\3\u0649\u0661\3\2\2\2",
    "\u064a\u064b\5\20\t\2\u064b\u064c\5\22\n\2\u064c\u064d\7\2\2\3\u064d",
    "\u0661\3\2\2\2\u064e\u064f\7)\2\2\u064f\u0650\5\16\b\2\u0650\u0651\7",
    "\2\2\3\u0651\u0661\3\2\2\2\u0652\u0653\7)\2\2\u0653\u0654\7=\2\2\u0654",
    "\u0655\5|?\2\u0655\u0656\7>\2\2\u0656\u0657\7\2\2\3\u0657\u0661\3\2",
    "\2\2\u0658\u0659\7\64\2\2\u0659\u065a\7=\2\2\u065a\u065b\5|?\2\u065b",
    "\u065c\7>\2\2\u065c\u065d\7\2\2\3\u065d\u0661\3\2\2\2\u065e\u065f\7",
    "R\2\2\u065f\u0661\7k\2\2\u0660\u063f\3\2\2\2\u0660\u0642\3\2\2\2\u0660",
    "\u0646\3\2\2\2\u0660\u064a\3\2\2\2\u0660\u064e\3\2\2\2\u0660\u0652\3",
    "\2\2\2\u0660\u0658\3\2\2\2\u0660\u065e\3\2\2\2\u0661\u00bb\3\2\2\2\u0662",
    "\u066a\7P\2\2\u0663\u066a\7M\2\2\u0664\u066a\7I\2\2\u0665\u066a\7K\2",
    "\2\u0666\u066a\7V\2\2\u0667\u0668\7U\2\2\u0668\u066a\7\2\2\3\u0669\u0662",
    "\3\2\2\2\u0669\u0663\3\2\2\2\u0669\u0664\3\2\2\2\u0669\u0665\3\2\2\2",
    "\u0669\u0666\3\2\2\2\u0669\u0667\3\2\2\2\u066a\u00bd\3\2\2\2\u066b\u066c",
    "\5\16\b\2\u066c\u066d\7\2\2\3\u066d\u067c\3\2\2\2\u066e\u066f\7=\2\2",
    "\u066f\u0670\5|?\2\u0670\u0671\7>\2\2\u0671\u0672\5\22\n\2\u0672\u0673",
    "\7\2\2\3\u0673\u067c\3\2\2\2\u0674\u0675\7\3\2\2\u0675\u0676\7=\2\2",
    "\u0676\u0677\5|?\2\u0677\u0678\7>\2\2\u0678\u0679\5\22\n\2\u0679\u067a",
    "\7\2\2\3\u067a\u067c\3\2\2\2\u067b\u066b\3\2\2\2\u067b\u066e\3\2\2\2",
    "\u067b\u0674\3\2\2\2\u067c\u00bf\3\2\2\2\u067d\u067e\5\22\n\2\u067e",
    "\u067f\7\2\2\3\u067f\u0690\3\2\2\2\u0680\u0681\5\24\13\2\u0681\u0682",
    "\7M\2\2\u0682\u0683\5\22\n\2\u0683\u0684\7\2\2\3\u0684\u0690\3\2\2\2",
    "\u0685\u0686\5\24\13\2\u0686\u0687\7N\2\2\u0687\u0688\5\22\n\2\u0688",
    "\u0689\7\2\2\3\u0689\u0690\3\2\2\2\u068a\u068b\5\24\13\2\u068b\u068c",
    "\7O\2\2\u068c\u068d\5\22\n\2\u068d\u068e\7\2\2\3\u068e\u0690\3\2\2\2",
    "\u068f\u067d\3\2\2\2\u068f\u0680\3\2\2\2\u068f\u0685\3\2\2\2\u068f\u068a",
    "\3\2\2\2\u0690\u00c1\3\2\2\2\u0691\u0692\5\24\13\2\u0692\u0693\7\2\2",
    "\3\u0693\u069f\3\2\2\2\u0694\u0695\5\26\f\2\u0695\u0696\7I\2\2\u0696",
    "\u0697\5\24\13\2\u0697\u0698\7\2\2\3\u0698\u069f\3\2\2\2\u0699\u069a",
    "\5\26\f\2\u069a\u069b\7K\2\2\u069b\u069c\5\24\13\2\u069c\u069d\7\2\2",
    "\3\u069d\u069f\3\2\2\2\u069e\u0691\3\2\2\2\u069e\u0694\3\2\2\2\u069e",
    "\u0699\3\2\2\2\u069f\u00c3\3\2\2\2\u06a0\u06a1\5\26\f\2\u06a1\u06a2",
    "\7\2\2\3\u06a2\u06ae\3\2\2\2\u06a3\u06a4\5\30\r\2\u06a4\u06a5\7G\2\2",
    "\u06a5\u06a6\5\26\f\2\u06a6\u06a7\7\2\2\3\u06a7\u06ae\3\2\2\2\u06a8",
    "\u06a9\5\30\r\2\u06a9\u06aa\7H\2\2\u06aa\u06ab\5\26\f\2\u06ab\u06ac",
    "\7\2\2\3\u06ac\u06ae\3\2\2\2\u06ad\u06a0\3\2\2\2\u06ad\u06a3\3\2\2\2",
    "\u06ad\u06a8\3\2\2\2\u06ae\u00c5\3\2\2\2\u06af\u06b0\5\30\r\2\u06b0",
    "\u06b1\7\2\2\3\u06b1\u06c7\3\2\2\2\u06b2\u06b3\5\32\16\2\u06b3\u06b4",
    "\7C\2\2\u06b4\u06b5\5\30\r\2\u06b5\u06b6\7\2\2\3\u06b6\u06c7\3\2\2\2",
    "\u06b7\u06b8\5\32\16\2\u06b8\u06b9\7E\2\2\u06b9\u06ba\5\30\r\2\u06ba",
    "\u06bb\7\2\2\3\u06bb\u06c7\3\2\2\2\u06bc\u06bd\5\32\16\2\u06bd\u06be",
    "\7D\2\2\u06be\u06bf\5\30\r\2\u06bf\u06c0\7\2\2\3\u06c0\u06c7\3\2\2\2",
    "\u06c1\u06c2\5\32\16\2\u06c2\u06c3\7F\2\2\u06c3\u06c4\5\30\r\2\u06c4",
    "\u06c5\7\2\2\3\u06c5\u06c7\3\2\2\2\u06c6\u06af\3\2\2\2\u06c6\u06b2\3",
    "\2\2\2\u06c6\u06b7\3\2\2\2\u06c6\u06bc\3\2\2\2\u06c6\u06c1\3\2\2\2\u06c7",
    "\u00c7\3\2\2\2\u06c8\u06c9\5\32\16\2\u06c9\u06ca\7\2\2\3\u06ca\u06d6",
    "\3\2\2\2\u06cb\u06cc\5\34\17\2\u06cc\u06cd\7f\2\2\u06cd\u06ce\5\32\16",
    "\2\u06ce\u06cf\7\2\2\3\u06cf\u06d6\3\2\2\2\u06d0\u06d1\5\34\17\2\u06d1",
    "\u06d2\7g\2\2\u06d2\u06d3\5\32\16\2\u06d3\u06d4\7\2\2\3\u06d4\u06d6",
    "\3\2\2\2\u06d5\u06c8\3\2\2\2\u06d5\u06cb\3\2\2\2\u06d5\u06d0\3\2\2\2",
    "\u06d6\u00c9\3\2\2\2\u06d7\u06d8\5\34\17\2\u06d8\u06d9\7\2\2\3\u06d9",
    "\u06e0\3\2\2\2\u06da\u06db\5\36\20\2\u06db\u06dc\7P\2\2\u06dc\u06dd",
    "\5\34\17\2\u06dd\u06de\7\2\2\3\u06de\u06e0\3\2\2\2\u06df\u06d7\3\2\2",
    "\2\u06df\u06da\3\2\2\2\u06e0\u00cb\3\2\2\2\u06e1\u06e2\5\36\20\2\u06e2",
    "\u06e3\7\2\2\3\u06e3\u06ea\3\2\2\2\u06e4\u06e5\5 \21\2\u06e5\u06e6\7",
    "T\2\2\u06e6\u06e7\5\36\20\2\u06e7\u06e8\7\2\2\3\u06e8\u06ea\3\2\2\2",
    "\u06e9\u06e1\3\2\2\2\u06e9\u06e4\3\2\2\2\u06ea\u00cd\3\2\2\2\u06eb\u06ec",
    "\5 \21\2\u06ec\u06ed\7\2\2\3\u06ed\u06f4\3\2\2\2\u06ee\u06ef\5\"\22",
    "\2\u06ef\u06f0\7Q\2\2\u06f0\u06f1\5 \21\2\u06f1\u06f2\7\2\2\3\u06f2",
    "\u06f4\3\2\2\2\u06f3\u06eb\3\2\2\2\u06f3\u06ee\3\2\2\2\u06f4\u00cf\3",
    "\2\2\2\u06f5\u06f6\5\"\22\2\u06f6\u06f7\7\2\2\3\u06f7\u06fe\3\2\2\2",
    "\u06f8\u06f9\5$\23\2\u06f9\u06fa\7R\2\2\u06fa\u06fb\5\"\22\2\u06fb\u06fc",
    "\7\2\2\3\u06fc\u06fe\3\2\2\2\u06fd\u06f5\3\2\2\2\u06fd\u06f8\3\2\2\2",
    "\u06fe\u00d1\3\2\2\2\u06ff\u0700\5$\23\2\u0700\u0701\7\2\2\3\u0701\u0708",
    "\3\2\2\2\u0702\u0703\5&\24\2\u0703\u0704\7S\2\2\u0704\u0705\5$\23\2",
    "\u0705\u0706\7\2\2\3\u0706\u0708\3\2\2\2\u0707\u06ff\3\2\2\2\u0707\u0702",
    "\3\2\2\2\u0708\u00d3\3\2\2\2\u0709\u070f\5&\24\2\u070a\u070b\7W\2\2",
    "\u070b\u070c\5.\30\2\u070c\u070d\7X\2\2\u070d\u070e\5(\25\2\u070e\u0710",
    "\3\2\2\2\u070f\u070a\3\2\2\2\u070f\u0710\3\2\2\2\u0710\u0711\3\2\2\2",
    "\u0711\u0712\7\2\2\3\u0712\u00d5\3\2\2\2\u0713\u0714\5(\25\2\u0714\u0715",
    "\7\2\2\3\u0715\u071c\3\2\2\2\u0716\u0717\5\16\b\2\u0717\u0718\5,\27",
    "\2\u0718\u0719\5*\26\2\u0719\u071a\7\2\2\3\u071a\u071c\3\2\2\2\u071b",
    "\u0713\3\2\2\2\u071b\u0716\3\2\2\2\u071c\u00d7\3\2\2\2\u071d\u072a\7",
    "[\2\2\u071e\u072a\7\\\2\2\u071f\u072a\7]\2\2\u0720\u072a\7^\2\2\u0721",
    "\u072a\7_\2\2\u0722\u072a\7`\2\2\u0723\u072a\7a\2\2\u0724\u072a\7b\2",
    "\2\u0725\u072a\7c\2\2\u0726\u072a\7d\2\2\u0727\u0728\7e\2\2\u0728\u072a",
    "\7\2\2\3\u0729\u071d\3\2\2\2\u0729\u071e\3\2\2\2\u0729\u071f\3\2\2\2",
    "\u0729\u0720\3\2\2\2\u0729\u0721\3\2\2\2\u0729\u0722\3\2\2\2\u0729\u0723",
    "\3\2\2\2\u0729\u0724\3\2\2\2\u0729\u0725\3\2\2\2\u0729\u0726\3\2\2\2",
    "\u0729\u0727\3\2\2\2\u072a\u00d9\3\2\2\2\u072b\u072c\5*\26\2\u072c\u072d",
    "\7\2\2\3\u072d\u0734\3\2\2\2\u072e\u072f\5.\30\2\u072f\u0730\7Z\2\2",
    "\u0730\u0731\5*\26\2\u0731\u0732\7\2\2\3\u0732\u0734\3\2\2\2\u0733\u072b",
    "\3\2\2\2\u0733\u072e\3\2\2\2\u0734\u00db\3\2\2\2\u0735\u0736\5(\25\2",
    "\u0736\u0737\7\2\2\3\u0737\u00dd\3\2\2\2\u0738\u073a\5\64\33\2\u0739",
    "\u073b\5:\36\2\u073a\u0739\3\2\2\2\u073a\u073b\3\2\2\2\u073b\u073c\3",
    "\2\2\2\u073c\u073d\7Y\2\2\u073d\u073e\7\2\2\3\u073e\u0743\3\2\2\2\u073f",
    "\u0740\5\u008eH\2\u0740\u0741\7\2\2\3\u0741\u0743\3\2\2\2\u0742\u0738",
    "\3\2\2\2\u0742\u073f\3\2\2\2\u0743\u00df\3\2\2\2\u0744\u0746\58\35\2",
    "\u0745\u0744\3\2\2\2\u0746\u0747\3\2\2\2\u0747\u0745\3\2\2\2\u0747\u0748",
    "\3\2\2\2\u0748\u0749\3\2\2\2\u0749\u074a\7\2\2\3\u074a\u00e1\3\2\2\2",
    "\u074b\u074d\58\35\2\u074c\u074b\3\2\2\2\u074d\u074e\3\2\2\2\u074e\u074c",
    "\3\2\2\2\u074e\u074f\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u0751\7\2\2\3",
    "\u0751\u00e3\3\2\2\2\u0752\u0753\5> \2\u0753\u0754\7\2\2\3\u0754\u0762",
    "\3\2\2\2\u0755\u0756\5@!\2\u0756\u0757\7\2\2\3\u0757\u0762\3\2\2\2\u0758",
    "\u0759\5\\/\2\u0759\u075a\7\2\2\3\u075a\u0762\3\2\2\2\u075b\u075c\5",
    "^\60\2\u075c\u075d\7\2\2\3\u075d\u0762\3\2\2\2\u075e\u075f\5`\61\2\u075f",
    "\u0760\7\2\2\3\u0760\u0762\3\2\2\2\u0761\u0752\3\2\2\2\u0761\u0755\3",
    "\2\2\2\u0761\u0758\3\2\2\2\u0761\u075b\3\2\2\2\u0761\u075e\3\2\2\2\u0762",
    "\u00e5\3\2\2\2\u0763\u0764\5<\37\2\u0764\u0765\7\2\2\3\u0765\u076c\3",
    "\2\2\2\u0766\u0767\5:\36\2\u0767\u0768\7Z\2\2\u0768\u0769\5<\37\2\u0769",
    "\u076a\7\2\2\3\u076a\u076c\3\2\2\2\u076b\u0763\3\2\2\2\u076b\u0766\3",
    "\2\2\2\u076c\u00e7\3\2\2\2\u076d\u076e\5b\62\2\u076e\u076f\7\2\2\3\u076f",
    "\u0776\3\2\2\2\u0770\u0771\5b\62\2\u0771\u0772\7[\2\2\u0772\u0773\5",
    "\u0084C\2\u0773\u0774\7\2\2\3\u0774\u0776\3\2\2\2\u0775\u076d\3\2\2",
    "\2\u0775\u0770\3\2\2\2\u0776\u00e9\3\2\2\2\u0777\u0778\7-\2\2\u0778",
    "\u0784\7\2\2\3\u0779\u077a\7\34\2\2\u077a\u0784\7\2\2\3\u077b\u077c",
    "\7*\2\2\u077c\u0784\7\2\2\3\u077d\u077e\7<\2\2\u077e\u0784\7\2\2\3\u077f",
    "\u0780\7\21\2\2\u0780\u0784\7\2\2\3\u0781\u0782\7$\2\2\u0782\u0784\7",
    "\2\2\3\u0783\u0777\3\2\2\2\u0783\u0779\3\2\2\2\u0783\u077b\3\2\2\2\u0783",
    "\u077d\3\2\2\2\u0783\u077f\3\2\2\2\u0783\u0781\3\2\2\2\u0784\u00eb\3",
    "\2\2\2\u0785\u0786\7\60\2\2\u0786\u07a1\7\2\2\3\u0787\u0788\7\24\2\2",
    "\u0788\u07a1\7\2\2\3\u0789\u078a\7\'\2\2\u078a\u07a1\7\2\2\3\u078b\u078c",
    "\7\"\2\2\u078c\u07a1\7\2\2\3\u078d\u078e\7#\2\2\u078e\u07a1\7\2\2\3",
    "\u078f\u0790\7\35\2\2\u0790\u07a1\7\2\2\3\u0791\u0792\7\31\2\2\u0792",
    "\u07a1\7\2\2\3\u0793\u0794\7(\2\2\u0794\u07a1\7\2\2\3\u0795\u0796\7",
    "/\2\2\u0796\u07a1\7\2\2\3\u0797\u0798\7\66\2\2\u0798\u07a1\7\2\2\3\u0799",
    "\u079a\7\67\2\2\u079a\u07a1\7\2\2\3\u079b\u079c\7\6\2\2\u079c\u07a1",
    "\7\2\2\3\u079d\u079e\7\7\2\2\u079e\u07a1\7\2\2\3\u079f\u07a1\7\b\2\2",
    "\u07a0\u0785\3\2\2\2\u07a0\u0787\3\2\2\2\u07a0\u0789\3\2\2\2\u07a0\u078b",
    "\3\2\2\2\u07a0\u078d\3\2\2\2\u07a0\u078f\3\2\2\2\u07a0\u0791\3\2\2\2",
    "\u07a0\u0793\3\2\2\2\u07a0\u0795\3\2\2\2\u07a0\u0797\3\2\2\2\u07a0\u0799",
    "\3\2\2\2\u07a0\u079b\3\2\2\2\u07a0\u079d\3\2\2\2\u07a0\u079f\3\2\2\2",
    "\u07a1\u07a2\3\2\2\2\u07a2\u07ba\7\2\2\3\u07a3\u07a4\7\3\2\2\u07a4\u07a5",
    "\7=\2\2\u07a5\u07a6\t\6\2\2\u07a6\u07a7\7>\2\2\u07a7\u07ba\7\2\2\3\u07a8",
    "\u07a9\5Z.\2\u07a9\u07aa\7\2\2\3\u07aa\u07ba\3\2\2\2\u07ab\u07ac\5B",
    "\"\2\u07ac\u07ad\7\2\2\3\u07ad\u07ba\3\2\2\2\u07ae\u07af\5R*\2\u07af",
    "\u07b0\7\2\2\3\u07b0\u07ba\3\2\2\2\u07b1\u07b2\5\u0082B\2\u07b2\u07b3",
    "\7\2\2\3\u07b3\u07ba\3\2\2\2\u07b4\u07b5\7\t\2\2\u07b5\u07b6\7=\2\2",
    "\u07b6\u07b7\5\60\31\2\u07b7\u07b8\7>\2\2\u07b8\u07ba\3\2\2\2\u07b9",
    "\u07a0\3\2\2\2\u07b9\u07a3\3\2\2\2\u07b9\u07a8\3\2\2\2\u07b9\u07ab\3",
    "\2\2\2\u07b9\u07ae\3\2\2\2\u07b9\u07b1\3\2\2\2\u07b9\u07b4\3\2\2\2\u07ba",
    "\u00ed\3\2\2\2\u07bb\u07bd\5D#\2\u07bc\u07be\7k\2\2\u07bd\u07bc\3\2",
    "\2\2\u07bd\u07be\3\2\2\2\u07be\u07bf\3\2\2\2\u07bf\u07c0\5F$\2\u07c0",
    "\u07c1\7\2\2\3\u07c1\u07c7\3\2\2\2\u07c2\u07c3\5D#\2\u07c3\u07c4\7k",
    "\2\2\u07c4\u07c5\7\2\2\3\u07c5\u07c7\3\2\2\2\u07c6\u07bb\3\2\2\2\u07c6",
    "\u07c2\3\2\2\2\u07c7\u00ef\3\2\2\2\u07c8\u07c9\7+\2\2\u07c9\u07cd\7",
    "\2\2\3\u07ca\u07cb\7.\2\2\u07cb\u07cd\7\2\2\3\u07cc\u07c8\3\2\2\2\u07cc",
    "\u07ca\3\2\2\2\u07cd\u00f1\3\2\2\2\u07ce\u07cf\7A\2\2\u07cf\u07d0\5",
    "H%\2\u07d0\u07d1\7B\2\2\u07d1\u07d2\7\2\2\3\u07d2\u00f3\3\2\2\2\u07d3",
    "\u07d4\5J&\2\u07d4\u07d5\7\2\2\3\u07d5\u07db\3\2\2\2\u07d6\u07d7\5H",
    "%\2\u07d7\u07d8\5J&\2\u07d8\u07d9\7\2\2\3\u07d9\u07db\3\2\2\2\u07da",
    "\u07d3\3\2\2\2\u07da\u07d6\3\2\2\2\u07db\u00f5\3\2\2\2\u07dc\u07de\5",
    "L\'\2\u07dd\u07df\5N(\2\u07de\u07dd\3\2\2\2\u07de\u07df\3\2\2\2\u07df",
    "\u07e0\3\2\2\2\u07e0\u07e1\7Y\2\2\u07e1\u07e2\7\2\2\3\u07e2\u07e7\3",
    "\2\2\2\u07e3\u07e4\5\u008eH\2\u07e4\u07e5\7\2\2\3\u07e5\u07e7\3\2\2",
    "\2\u07e6\u07dc\3\2\2\2\u07e6\u07e3\3\2\2\2\u07e7\u00f7\3\2\2\2\u07e8",
    "\u07ea\5@!\2\u07e9\u07eb\5L\'\2\u07ea\u07e9\3\2\2\2\u07ea\u07eb\3\2",
    "\2\2\u07eb\u07ec\3\2\2\2\u07ec\u07ed\7\2\2\3\u07ed\u07f5\3\2\2\2\u07ee",
    "\u07f0\5\\/\2\u07ef\u07f1\5L\'\2\u07f0\u07ef\3\2\2\2\u07f0\u07f1\3\2",
    "\2\2\u07f1\u07f2\3\2\2\2\u07f2\u07f3\7\2\2\3\u07f3\u07f5\3\2\2\2\u07f4",
    "\u07e8\3\2\2\2\u07f4\u07ee\3\2\2\2\u07f5\u00f9\3\2\2\2\u07f6\u07f7\5",
    "P)\2\u07f7\u07f8\7\2\2\3\u07f8\u07ff\3\2\2\2\u07f9\u07fa\5N(\2\u07fa",
    "\u07fb\7Z\2\2\u07fb\u07fc\5P)\2\u07fc\u07fd\7\2\2\3\u07fd\u07ff\3\2",
    "\2\2\u07fe\u07f6\3\2\2\2\u07fe\u07f9\3\2\2\2\u07ff\u00fb\3\2\2\2\u0800",
    "\u0801\5b\62\2\u0801\u0802\7\2\2\3\u0802\u080b\3\2\2\2\u0803\u0805\5",
    "b\62\2\u0804\u0803\3\2\2\2\u0804\u0805\3\2\2\2\u0805\u0806\3\2\2\2\u0806",
    "\u0807\7X\2\2\u0807\u0808\5\60\31\2\u0808\u0809\7\2\2\3\u0809\u080b",
    "\3\2\2\2\u080a\u0800\3\2\2\2\u080a\u0804\3\2\2\2\u080b\u00fd\3\2\2\2",
    "\u080c\u080e\7\33\2\2\u080d\u080f\7k\2\2\u080e\u080d\3\2\2\2\u080e\u080f",
    "\3\2\2\2\u080f\u0810\3\2\2\2\u0810\u0811\7A\2\2\u0811\u0812\5T+\2\u0812",
    "\u0813\7B\2\2\u0813\u0814\7\2\2\3\u0814\u0823\3\2\2\2\u0815\u0817\7",
    "\33\2\2\u0816\u0818\7k\2\2\u0817\u0816\3\2\2\2\u0817\u0818\3\2\2\2\u0818",
    "\u0819\3\2\2\2\u0819\u081a\7A\2\2\u081a\u081b\5T+\2\u081b\u081c\7Z\2",
    "\2\u081c\u081d\7B\2\2\u081d\u081e\7\2\2\3\u081e\u0823\3\2\2\2\u081f",
    "\u0820\7\33\2\2\u0820\u0821\7k\2\2\u0821\u0823\7\2\2\3\u0822\u080c\3",
    "\2\2\2\u0822\u0815\3\2\2\2\u0822\u081f\3\2\2\2\u0823\u00ff\3\2\2\2\u0824",
    "\u0825\5V,\2\u0825\u0826\7\2\2\3\u0826\u082d\3\2\2\2\u0827\u0828\5T",
    "+\2\u0828\u0829\7Z\2\2\u0829\u082a\5V,\2\u082a\u082b\7\2\2\3\u082b\u082d",
    "\3\2\2\2\u082c\u0824\3\2\2\2\u082c\u0827\3\2\2\2\u082d\u0101\3\2\2\2",
    "\u082e\u082f\5X-\2\u082f\u0830\7\2\2\3\u0830\u0837\3\2\2\2\u0831\u0832",
    "\5X-\2\u0832\u0833\7[\2\2\u0833\u0834\5\60\31\2\u0834\u0835\7\2\2\3",
    "\u0835\u0837\3\2\2\2\u0836\u082e\3\2\2\2\u0836\u0831\3\2\2\2\u0837\u0103",
    "\3\2\2\2\u0838\u0839\7k\2\2\u0839\u083a\7\2\2\3\u083a\u0105\3\2\2\2",
    "\u083b\u083c\7\65\2\2\u083c\u083d\7=\2\2\u083d\u083e\5|?\2\u083e\u083f",
    "\7>\2\2\u083f\u0840\7\2\2\3\u0840\u0107\3\2\2\2\u0841\u0842\7\25\2\2",
    "\u0842\u084a\7\2\2\3\u0843\u0844\7%\2\2\u0844\u084a\7\2\2\3\u0845\u0846",
    "\7\61\2\2\u0846\u084a\7\2\2\3\u0847\u0848\7\65\2\2\u0848\u084a\7\2\2",
    "\3\u0849\u0841\3\2\2\2\u0849\u0843\3\2\2\2\u0849\u0845\3\2\2\2\u0849",
    "\u0847\3\2\2\2\u084a\u0109\3\2\2\2\u084b\u084c\7!\2\2\u084c\u0852\7",
    "\2\2\3\u084d\u084e\7:\2\2\u084e\u0852\7\2\2\3\u084f\u0852\7\n\2\2\u0850",
    "\u0852\7\13\2\2\u0851\u084b\3\2\2\2\u0851\u084d\3\2\2\2\u0851\u084f",
    "\3\2\2\2\u0851\u0850\3\2\2\2\u0852\u0853\3\2\2\2\u0853\u085d\7\2\2\3",
    "\u0854\u0855\5h\65\2\u0855\u0856\7\2\2\3\u0856\u085d\3\2\2\2\u0857\u0858",
    "\7\f\2\2\u0858\u0859\7=\2\2\u0859\u085a\7k\2\2\u085a\u085b\7>\2\2\u085b",
    "\u085d\7\2\2\3\u085c\u0851\3\2\2\2\u085c\u0854\3\2\2\2\u085c\u0857\3",
    "\2\2\2\u085d\u010b\3\2\2\2\u085e\u085f\7\63\2\2\u085f\u0860\7=\2\2\u0860",
    "\u0861\5|?\2\u0861\u0862\7>\2\2\u0862\u0863\7\2\2\3\u0863\u086b\3\2",
    "\2\2\u0864\u0865\7\63\2\2\u0865\u0866\7=\2\2\u0866\u0867\5\60\31\2\u0867",
    "\u0868\7>\2\2\u0868\u0869\7\2\2\3\u0869\u086b\3\2\2\2\u086a\u085e\3",
    "\2\2\2\u086a\u0864\3\2\2\2\u086b\u010d\3\2\2\2\u086c\u086e\5p9\2\u086d",
    "\u086c\3\2\2\2\u086d\u086e\3\2\2\2\u086e\u086f\3\2\2\2\u086f\u0873\5",
    "d\63\2\u0870\u0872\5f\64\2\u0871\u0870\3\2\2\2\u0872\u0875\3\2\2\2\u0873",
    "\u0871\3\2\2\2\u0873\u0874\3\2\2\2\u0874\u0876\3\2\2\2\u0875\u0873\3",
    "\2\2\2\u0876\u0877\7\2\2\3\u0877\u010f\3\2\2\2\u0878\u0879\7k\2\2\u0879",
    "\u08b4\7\2\2\3\u087a\u087b\7=\2\2\u087b\u087c\5b\62\2\u087c\u087d\7",
    ">\2\2\u087d\u087e\7\2\2\3\u087e\u08b4\3\2\2\2\u087f\u0880\5d\63\2\u0880",
    "\u0882\7?\2\2\u0881\u0883\5r:\2\u0882\u0881\3\2\2\2\u0882\u0883\3\2",
    "\2\2\u0883\u0885\3\2\2\2\u0884\u0886\5*\26\2\u0885\u0884\3\2\2\2\u0885",
    "\u0886\3\2\2\2\u0886\u0887\3\2\2\2\u0887\u0888\7@\2\2\u0888\u0889\7",
    "\2\2\3\u0889\u08b4\3\2\2\2\u088a\u088b\5d\63\2\u088b\u088c\7?\2\2\u088c",
    "\u088e\7*\2\2\u088d\u088f\5r:\2\u088e\u088d\3\2\2\2\u088e\u088f\3\2",
    "\2\2\u088f\u0890\3\2\2\2\u0890\u0891\5*\26\2\u0891\u0892\7@\2\2\u0892",
    "\u0893\7\2\2\3\u0893\u08b4\3\2\2\2\u0894\u0895\5d\63\2\u0895\u0896\7",
    "?\2\2\u0896\u0897\5r:\2\u0897\u0898\7*\2\2\u0898\u0899\5*\26\2\u0899",
    "\u089a\7@\2\2\u089a\u089b\7\2\2\3\u089b\u08b4\3\2\2\2\u089c\u089d\5",
    "d\63\2\u089d\u089f\7?\2\2\u089e\u08a0\5r:\2\u089f\u089e\3\2\2\2\u089f",
    "\u08a0\3\2\2\2\u08a0\u08a1\3\2\2\2\u08a1\u08a2\7M\2\2\u08a2\u08a3\7",
    "@\2\2\u08a3\u08a4\7\2\2\3\u08a4\u08b4\3\2\2\2\u08a5\u08a6\5d\63\2\u08a6",
    "\u08a7\7=\2\2\u08a7\u08a8\5t;\2\u08a8\u08a9\7>\2\2\u08a9\u08aa\7\2\2",
    "\3\u08aa\u08b4\3\2\2\2\u08ab\u08ac\5d\63\2\u08ac\u08ae\7=\2\2\u08ad",
    "\u08af\5z>\2\u08ae\u08ad\3\2\2\2\u08ae\u08af\3\2\2\2\u08af\u08b0\3\2",
    "\2\2\u08b0\u08b1\7>\2\2\u08b1\u08b2\7\2\2\3\u08b2\u08b4\3\2\2\2\u08b3",
    "\u0878\3\2\2\2\u08b3\u087a\3\2\2\2\u08b3\u087f\3\2\2\2\u08b3\u088a\3",
    "\2\2\2\u08b3\u0894\3\2\2\2\u08b3\u089c\3\2\2\2\u08b3\u08a5\3\2\2\2\u08b3",
    "\u08ab\3\2\2\2\u08b4\u0111\3\2\2\2\u08b5\u08b6\7\r\2\2\u08b6\u08b8\7",
    "=\2\2\u08b7\u08b9\7m\2\2\u08b8\u08b7\3\2\2\2\u08b9\u08ba\3\2\2\2\u08ba",
    "\u08b8\3\2\2\2\u08ba\u08bb\3\2\2\2\u08bb\u08bc\3\2\2\2\u08bc\u08bd\7",
    ">\2\2\u08bd\u08c2\7\2\2\3\u08be\u08bf\5h\65\2\u08bf\u08c0\7\2\2\3\u08c0",
    "\u08c2\3\2\2\2\u08c1\u08b5\3\2\2\2\u08c1\u08be\3\2\2\2\u08c2\u0113\3",
    "\2\2\2\u08c3\u08c4\7\16\2\2\u08c4\u08c5\7=\2\2\u08c5\u08c6\7=\2\2\u08c6",
    "\u08c7\5j\66\2\u08c7\u08c8\7>\2\2\u08c8\u08c9\7>\2\2\u08c9\u08ca\7\2",
    "\2\3\u08ca\u0115\3\2\2\2\u08cb\u08d0\5l\67\2\u08cc\u08cd\7Z\2\2\u08cd",
    "\u08cf\5l\67\2\u08ce\u08cc\3\2\2\2\u08cf\u08d2\3\2\2\2\u08d0\u08ce\3",
    "\2\2\2\u08d0\u08d1\3\2\2\2\u08d1\u08d3\3\2\2\2\u08d2\u08d0\3\2\2\2\u08d3",
    "\u08d4\7\2\2\3\u08d4\u08d7\3\2\2\2\u08d5\u08d7\3\2\2\2\u08d6\u08cb\3",
    "\2\2\2\u08d6\u08d5\3\2\2\2\u08d7\u0117\3\2\2\2\u08d8\u08de\n\n\2\2\u08d9",
    "\u08db\7=\2\2\u08da\u08dc\5\f\7\2\u08db\u08da\3\2\2\2\u08db\u08dc\3",
    "\2\2\2\u08dc\u08dd\3\2\2\2\u08dd\u08df\7>\2\2\u08de\u08d9\3\2\2\2\u08de",
    "\u08df\3\2\2\2\u08df\u08e2\3\2\2\2\u08e0\u08e2\3\2\2\2\u08e1\u08d8\3",
    "\2\2\2\u08e1\u08e0\3\2\2\2\u08e2\u0119\3\2\2\2\u08e3\u08e4\n\13\2\2",
    "\u08e4\u08eb\7\2\2\3\u08e5\u08e6\7=\2\2\u08e6\u08e7\5n8\2\u08e7\u08e8",
    "\7>\2\2\u08e8\u08e9\7\2\2\3\u08e9\u08eb\3\2\2\2\u08ea\u08e3\3\2\2\2",
    "\u08ea\u08e5\3\2\2\2\u08eb\u08ee\3\2\2\2\u08ec\u08ea\3\2\2\2\u08ec\u08ed",
    "\3\2\2\2\u08ed\u011b\3\2\2\2\u08ee\u08ec\3\2\2\2\u08ef\u08f1\7M\2\2",
    "\u08f0\u08f2\5r:\2\u08f1\u08f0\3\2\2\2\u08f1\u08f2\3\2\2\2\u08f2\u08f3",
    "\3\2\2\2\u08f3\u0905\7\2\2\3\u08f4\u08f6\7M\2\2\u08f5\u08f7\5r:\2\u08f6",
    "\u08f5\3\2\2\2\u08f6\u08f7\3\2\2\2\u08f7\u08f8\3\2\2\2\u08f8\u08f9\5",
    "p9\2\u08f9\u08fa\7\2\2\3\u08fa\u0905\3\2\2\2\u08fb\u08fd\7T\2\2\u08fc",
    "\u08fe\5r:\2\u08fd\u08fc\3\2\2\2\u08fd\u08fe\3\2\2\2\u08fe\u0905\3\2",
    "\2\2\u08ff\u0901\7T\2\2\u0900\u0902\5r:\2\u0901\u0900\3\2\2\2\u0901",
    "\u0902\3\2\2\2\u0902\u0903\3\2\2\2\u0903\u0905\5p9\2\u0904\u08ef\3\2",
    "\2\2\u0904\u08f4\3\2\2\2\u0904\u08fb\3\2\2\2\u0904\u08ff\3\2\2\2\u0905",
    "\u011d\3\2\2\2\u0906\u0907\5\\/\2\u0907\u0908\7\2\2\3\u0908\u090e\3",
    "\2\2\2\u0909\u090a\5r:\2\u090a\u090b\5\\/\2\u090b\u090c\7\2\2\3\u090c",
    "\u090e\3\2\2\2\u090d\u0906\3\2\2\2\u090d\u0909\3\2\2\2\u090e\u011f\3",
    "\2\2\2\u090f\u0910\5v<\2\u0910\u0911\7\2\2\3\u0911\u0918\3\2\2\2\u0912",
    "\u0913\5v<\2\u0913\u0914\7Z\2\2\u0914\u0915\7j\2\2\u0915\u0916\7\2\2",
    "\3\u0916\u0918\3\2\2\2\u0917\u090f\3\2\2\2\u0917\u0912\3\2\2\2\u0918",
    "\u0121\3\2\2\2\u0919\u091a\5x=\2\u091a\u091b\7\2\2\3\u091b\u0922\3\2",
    "\2\2\u091c\u091d\5v<\2\u091d\u091e\7Z\2\2\u091e\u091f\5x=\2\u091f\u0920",
    "\7\2\2\3\u0920\u0922\3\2\2\2\u0921\u0919\3\2\2\2\u0921\u091c\3\2\2\2",
    "\u0922\u0123\3\2\2\2\u0923\u0924\5\64\33\2\u0924\u0925\5b\62\2\u0925",
    "\u0926\7\2\2\3\u0926\u092e\3\2\2\2\u0927\u0929\5\66\34\2\u0928\u092a",
    "\5~@\2\u0929\u0928\3\2\2\2\u0929\u092a\3\2\2\2\u092a\u092b\3\2\2\2\u092b",
    "\u092c\7\2\2\3\u092c\u092e\3\2\2\2\u092d\u0923\3\2\2\2\u092d\u0927\3",
    "\2\2\2\u092e\u0125\3\2\2\2\u092f\u0930\7k\2\2\u0930\u0937\7\2\2\3\u0931",
    "\u0932\5z>\2\u0932\u0933\7Z\2\2\u0933\u0934\7k\2\2\u0934\u0935\7\2\2",
    "\3\u0935\u0937\3\2\2\2\u0936\u092f\3\2\2\2\u0936\u0931\3\2\2\2\u0937",
    "\u0127\3\2\2\2\u0938\u093a\5L\'\2\u0939\u093b\5~@\2\u093a\u0939\3\2",
    "\2\2\u093a\u093b\3\2\2\2\u093b\u093c\3\2\2\2\u093c\u093d\7\2\2\3\u093d",
    "\u0129\3\2\2\2\u093e\u093f\5p9\2\u093f\u0940\7\2\2\3\u0940\u094e\3\2",
    "\2\2\u0941\u0943\5p9\2\u0942\u0941\3\2\2\2\u0942\u0943\3\2\2\2\u0943",
    "\u0944\3\2\2\2\u0944\u0948\5\u0080A\2\u0945\u0947\5f\64\2\u0946\u0945",
    "\3\2\2\2\u0947\u094a\3\2\2\2\u0948\u0946\3\2\2\2\u0948\u0949\3\2\2\2",
    "\u0949\u094b\3\2\2\2\u094a\u0948\3\2\2\2\u094b\u094c\7\2\2\3\u094c\u094e",
    "\3\2\2\2\u094d\u093e\3\2\2\2\u094d\u0942\3\2\2\2\u094e\u012b\3\2\2\2",
    "\u094f\u0950\7=\2\2\u0950\u0951\5~@\2\u0951\u0955\7>\2\2\u0952\u0954",
    "\5f\64\2\u0953\u0952\3\2\2\2\u0954\u0957\3\2\2\2\u0955\u0953\3\2\2\2",
    "\u0955\u0956\3\2\2\2\u0956\u0958\3\2\2\2\u0957\u0955\3\2\2\2\u0958\u0959",
    "\7\2\2\3\u0959\u09b5\3\2\2\2\u095a\u095c\7?\2\2\u095b\u095d\5r:\2\u095c",
    "\u095b\3\2\2\2\u095c\u095d\3\2\2\2\u095d\u095f\3\2\2\2\u095e\u0960\5",
    "*\26\2\u095f\u095e\3\2\2\2\u095f\u0960\3\2\2\2\u0960\u0961\3\2\2\2\u0961",
    "\u0962\7@\2\2\u0962\u09b5\7\2\2\3\u0963\u0964\7?\2\2\u0964\u0966\7*",
    "\2\2\u0965\u0967\5r:\2\u0966\u0965\3\2\2\2\u0966\u0967\3\2\2\2\u0967",
    "\u0968\3\2\2\2\u0968\u0969\5*\26\2\u0969\u096a\7@\2\2\u096a\u096b\7",
    "\2\2\3\u096b\u09b5\3\2\2\2\u096c\u096d\7?\2\2\u096d\u096e\5r:\2\u096e",
    "\u096f\7*\2\2\u096f\u0970\5*\26\2\u0970\u0971\7@\2\2\u0971\u0972\7\2",
    "\2\3\u0972\u09b5\3\2\2\2\u0973\u0974\7?\2\2\u0974\u0975\7M\2\2\u0975",
    "\u0976\7@\2\2\u0976\u09b5\7\2\2\3\u0977\u0979\7=\2\2\u0978\u097a\5t",
    ";\2\u0979\u0978\3\2\2\2\u0979\u097a\3\2\2\2\u097a\u097b\3\2\2\2\u097b",
    "\u097f\7>\2\2\u097c\u097e\5f\64\2\u097d\u097c\3\2\2\2\u097e\u0981\3",
    "\2\2\2\u097f\u097d\3\2\2\2\u097f\u0980\3\2\2\2\u0980\u0982\3\2\2\2\u0981",
    "\u097f\3\2\2\2\u0982\u09b5\7\2\2\3\u0983\u0984\5\u0080A\2\u0984\u0986",
    "\7?\2\2\u0985\u0987\5r:\2\u0986\u0985\3\2\2\2\u0986\u0987\3\2\2\2\u0987",
    "\u0989\3\2\2\2\u0988\u098a\5*\26\2\u0989\u0988\3\2\2\2\u0989\u098a\3",
    "\2\2\2\u098a\u098b\3\2\2\2\u098b\u098c\7@\2\2\u098c\u098d\7\2\2\3\u098d",
    "\u09b5\3\2\2\2\u098e\u098f\5\u0080A\2\u098f\u0990\7?\2\2\u0990\u0992",
    "\7*\2\2\u0991\u0993\5r:\2\u0992\u0991\3\2\2\2\u0992\u0993\3\2\2\2\u0993",
    "\u0994\3\2\2\2\u0994\u0995\5*\26\2\u0995\u0996\7@\2\2\u0996\u0997\7",
    "\2\2\3\u0997\u09b5\3\2\2\2\u0998\u0999\5\u0080A\2\u0999\u099a\7?\2\2",
    "\u099a\u099b\5r:\2\u099b\u099c\7*\2\2\u099c\u099d\5*\26\2\u099d\u099e",
    "\7@\2\2\u099e\u099f\7\2\2\3\u099f\u09b5\3\2\2\2\u09a0\u09a1\5\u0080",
    "A\2\u09a1\u09a2\7?\2\2\u09a2\u09a3\7M\2\2\u09a3\u09a4\7@\2\2\u09a4\u09a5",
    "\7\2\2\3\u09a5\u09b5\3\2\2\2\u09a6\u09a7\5\u0080A\2\u09a7\u09a9\7=\2",
    "\2\u09a8\u09aa\5t;\2\u09a9\u09a8\3\2\2\2\u09a9\u09aa\3\2\2\2\u09aa\u09ab",
    "\3\2\2\2\u09ab\u09af\7>\2\2\u09ac\u09ae\5f\64\2\u09ad\u09ac\3\2\2\2",
    "\u09ae\u09b1\3\2\2\2\u09af\u09ad\3\2\2\2\u09af\u09b0\3\2\2\2\u09b0\u09b2",
    "\3\2\2\2\u09b1\u09af\3\2\2\2\u09b2\u09b3\7\2\2\3\u09b3\u09b5\3\2\2\2",
    "\u09b4\u094f\3\2\2\2\u09b4\u095a\3\2\2\2\u09b4\u0963\3\2\2\2\u09b4\u096c",
    "\3\2\2\2\u09b4\u0973\3\2\2\2\u09b4\u0977\3\2\2\2\u09b4\u0983\3\2\2\2",
    "\u09b4\u098e\3\2\2\2\u09b4\u0998\3\2\2\2\u09b4\u09a0\3\2\2\2\u09b4\u09a6",
    "\3\2\2\2\u09b5\u012d\3\2\2\2\u09b6\u09b7\7k\2\2\u09b7\u09b8\7\2\2\3",
    "\u09b8\u012f\3\2\2\2\u09b9\u09ba\5*\26\2\u09ba\u09bb\7\2\2\3\u09bb\u09c8",
    "\3\2\2\2\u09bc\u09bd\7A\2\2\u09bd\u09be\5\u0086D\2\u09be\u09bf\7B\2",
    "\2\u09bf\u09c0\7\2\2\3\u09c0\u09c8\3\2\2\2\u09c1\u09c2\7A\2\2\u09c2",
    "\u09c3\5\u0086D\2\u09c3\u09c4\7Z\2\2\u09c4\u09c5\7B\2\2\u09c5\u09c6",
    "\7\2\2\3\u09c6\u09c8\3\2\2\2\u09c7\u09b9\3\2\2\2\u09c7\u09bc\3\2\2\2",
    "\u09c7\u09c1\3\2\2\2\u09c8\u0131\3\2\2\2\u09c9\u09cb\5\u0088E\2\u09ca",
    "\u09c9\3\2\2\2\u09ca\u09cb\3\2\2\2\u09cb\u09cc\3\2\2\2\u09cc\u09cd\5",
    "\u0084C\2\u09cd\u09ce\7\2\2\3\u09ce\u09d8\3\2\2\2\u09cf\u09d0\5\u0086",
    "D\2\u09d0\u09d2\7Z\2\2\u09d1\u09d3\5\u0088E\2\u09d2\u09d1\3\2\2\2\u09d2",
    "\u09d3\3\2\2\2\u09d3\u09d4\3\2\2\2\u09d4\u09d5\5\u0084C\2\u09d5\u09d6",
    "\7\2\2\3\u09d6\u09d8\3\2\2\2\u09d7\u09ca\3\2\2\2\u09d7\u09cf\3\2\2\2",
    "\u09d8\u0133\3\2\2\2\u09d9\u09da\5\u008aF\2\u09da\u09db\7[\2\2\u09db",
    "\u09dc\7\2\2\3\u09dc\u0135\3\2\2\2\u09dd\u09de\5\u008cG\2\u09de\u09df",
    "\7\2\2\3\u09df\u09e5\3\2\2\2\u09e0\u09e1\5\u008aF\2\u09e1\u09e2\5\u008c",
    "G\2\u09e2\u09e3\7\2\2\3\u09e3\u09e5\3\2\2\2\u09e4\u09dd\3\2\2\2\u09e4",
    "\u09e0\3\2\2\2\u09e5\u0137\3\2\2\2\u09e6\u09e7\7?\2\2\u09e7\u09e8\5",
    "\60\31\2\u09e8\u09e9\7@\2\2\u09e9\u09ea\7\2\2\3\u09ea\u09ef\3\2\2\2",
    "\u09eb\u09ec\7i\2\2\u09ec\u09ed\7k\2\2\u09ed\u09ef\7\2\2\3\u09ee\u09e6",
    "\3\2\2\2\u09ee\u09eb\3\2\2\2\u09ef\u0139\3\2\2\2\u09f0\u09f1\7;\2\2",
    "\u09f1\u09f2\7=\2\2\u09f2\u09f3\5\60\31\2\u09f3\u09f5\7Z\2\2\u09f4\u09f6",
    "\7m\2\2\u09f5\u09f4\3\2\2\2\u09f6\u09f7\3\2\2\2\u09f7\u09f5\3\2\2\2",
    "\u09f7\u09f8\3\2\2\2\u09f8\u09f9\3\2\2\2\u09f9\u09fa\7>\2\2\u09fa\u09fb",
    "\7Y\2\2\u09fb\u09fc\7\2\2\3\u09fc\u013b\3\2\2\2\u09fd\u09fe\5\u0092",
    "J\2\u09fe\u09ff\7\2\2\3\u09ff\u0a30\3\2\2\2\u0a00\u0a01\5\u0094K\2\u0a01",
    "\u0a02\7\2\2\3\u0a02\u0a30\3\2\2\2\u0a03\u0a04\5\u009cO\2\u0a04\u0a05",
    "\7\2\2\3\u0a05\u0a30\3\2\2\2\u0a06\u0a07\5\u009eP\2\u0a07\u0a08\7\2",
    "\2\3\u0a08\u0a30\3\2\2\2\u0a09\u0a0a\5\u00a0Q\2\u0a0a\u0a0b\7\2\2\3",
    "\u0a0b\u0a30\3\2\2\2\u0a0c\u0a0d\5\u00a2R\2\u0a0d\u0a0e\7\2\2\3\u0a0e",
    "\u0a30\3\2\2\2\u0a0f\u0a10\t\f\2\2\u0a10\u0a11\t\r\2\2\u0a11\u0a1a\7",
    "=\2\2\u0a12\u0a17\5&\24\2\u0a13\u0a14\7Z\2\2\u0a14\u0a16\5&\24\2\u0a15",
    "\u0a13\3\2\2\2\u0a16\u0a19\3\2\2\2\u0a17\u0a15\3\2\2\2\u0a17\u0a18\3",
    "\2\2\2\u0a18\u0a1b\3\2\2\2\u0a19\u0a17\3\2\2\2\u0a1a\u0a12\3\2\2\2\u0a1a",
    "\u0a1b\3\2\2\2\u0a1b\u0a29\3\2\2\2\u0a1c\u0a25\7X\2\2\u0a1d\u0a22\5",
    "&\24\2\u0a1e\u0a1f\7Z\2\2\u0a1f\u0a21\5&\24\2\u0a20\u0a1e\3\2\2\2\u0a21",
    "\u0a24\3\2\2\2\u0a22\u0a20\3\2\2\2\u0a22\u0a23\3\2\2\2\u0a23\u0a26\3",
    "\2\2\2\u0a24\u0a22\3\2\2\2\u0a25\u0a1d\3\2\2\2\u0a25\u0a26\3\2\2\2\u0a26",
    "\u0a28\3\2\2\2\u0a27\u0a1c\3\2\2\2\u0a28\u0a2b\3\2\2\2\u0a29\u0a27\3",
    "\2\2\2\u0a29\u0a2a\3\2\2\2\u0a2a\u0a2c\3\2\2\2\u0a2b\u0a29\3\2\2\2\u0a2c",
    "\u0a2d\7>\2\2\u0a2d\u0a2e\7Y\2\2\u0a2e\u0a30\7\2\2\3\u0a2f\u09fd\3\2",
    "\2\2\u0a2f\u0a00\3\2\2\2\u0a2f\u0a03\3\2\2\2\u0a2f\u0a06\3\2\2\2\u0a2f",
    "\u0a09\3\2\2\2\u0a2f\u0a0c\3\2\2\2\u0a2f\u0a0f\3\2\2\2\u0a30\u013d\3",
    "\2\2\2\u0a31\u0a32\7k\2\2\u0a32\u0a33\7X\2\2\u0a33\u0a34\5\u0090I\2",
    "\u0a34\u0a35\7\2\2\3\u0a35\u0a42\3\2\2\2\u0a36\u0a37\7\23\2\2\u0a37",
    "\u0a38\5\60\31\2\u0a38\u0a39\7X\2\2\u0a39\u0a3a\5\u0090I\2\u0a3a\u0a3b",
    "\7\2\2\3\u0a3b\u0a42\3\2\2\2\u0a3c\u0a3d\7\27\2\2\u0a3d\u0a3e\7X\2\2",
    "\u0a3e\u0a3f\5\u0090I\2\u0a3f\u0a40\7\2\2\3\u0a40\u0a42\3\2\2\2\u0a41",
    "\u0a31\3\2\2\2\u0a41\u0a36\3\2\2\2\u0a41\u0a3c\3\2\2\2\u0a42\u013f\3",
    "\2\2\2\u0a43\u0a45\7A\2\2\u0a44\u0a46\5\u0096L\2\u0a45\u0a44\3\2\2\2",
    "\u0a45\u0a46\3\2\2\2\u0a46\u0a47\3\2\2\2\u0a47\u0a48\7B\2\2\u0a48\u0a49",
    "\7\2\2\3\u0a49\u0141\3\2\2\2\u0a4a\u0a4b\5\u0098M\2\u0a4b\u0a4c\7\2",
    "\2\3\u0a4c\u0a52\3\2\2\2\u0a4d\u0a4e\5\u0096L\2\u0a4e\u0a4f\5\u0098",
    "M\2\u0a4f\u0a50\7\2\2\3\u0a50\u0a52\3\2\2\2\u0a51\u0a4a\3\2\2\2\u0a51",
    "\u0a4d\3\2\2\2\u0a52\u0143\3\2\2\2\u0a53\u0a54\5\u009aN\2\u0a54\u0a55",
    "\7\2\2\3\u0a55\u0a5e\3\2\2\2\u0a56\u0a57\5\62\32\2\u0a57\u0a58\7\2\2",
    "\3\u0a58\u0a5e\3\2\2\2\u0a59\u0a5a\5\u0090I\2\u0a5a\u0a5b\7\2\2\3\u0a5b",
    "\u0a5e\3\2\2\2\u0a5c\u0a5e\7\2\2\3\u0a5d\u0a53\3\2\2\2\u0a5d\u0a56\3",
    "\2\2\2\u0a5d\u0a59\3\2\2\2\u0a5d\u0a5c\3\2\2\2\u0a5e\u0145\3\2\2\2\u0a5f",
    "\u0a60\7k\2\2\u0a60\u0a61\7=\2\2\u0a61\u0a62\5*\26\2\u0a62\u0a63\7>",
    "\2\2\u0a63\u0a64\7Y\2\2\u0a64\u0a65\7\2\2\3\u0a65\u0147\3\2\2\2\u0a66",
    "\u0a68\5.\30\2\u0a67\u0a66\3\2\2\2\u0a67\u0a68\3\2\2\2\u0a68\u0a69\3",
    "\2\2\2\u0a69\u0a6a\7Y\2\2\u0a6a\u0a6b\7\2\2\3\u0a6b\u0149\3\2\2\2\u0a6c",
    "\u0a6d\7 \2\2\u0a6d\u0a6e\7=\2\2\u0a6e\u0a6f\5.\30\2\u0a6f\u0a70\7>",
    "\2\2\u0a70\u0a73\5\u0090I\2\u0a71\u0a72\7\32\2\2\u0a72\u0a74\5\u0090",
    "I\2\u0a73\u0a71\3\2\2\2\u0a73\u0a74\3\2\2\2\u0a74\u0a75\3\2\2\2\u0a75",
    "\u0a76\7\2\2\3\u0a76\u0a7f\3\2\2\2\u0a77\u0a78\7,\2\2\u0a78\u0a79\7",
    "=\2\2\u0a79\u0a7a\5.\30\2\u0a7a\u0a7b\7>\2\2\u0a7b\u0a7c\5\u0090I\2",
    "\u0a7c\u0a7d\7\2\2\3\u0a7d\u0a7f\3\2\2\2\u0a7e\u0a6c\3\2\2\2\u0a7e\u0a77",
    "\3\2\2\2\u0a7f\u014b\3\2\2\2\u0a80\u0a81\7\62\2\2\u0a81\u0a82\7=\2\2",
    "\u0a82\u0a83\5.\30\2\u0a83\u0a84\7>\2\2\u0a84\u0a85\5\u0090I\2\u0a85",
    "\u0a86\7\2\2\3\u0a86\u0ab0\3\2\2\2\u0a87\u0a88\7\30\2\2\u0a88\u0a89",
    "\5\u0090I\2\u0a89\u0a8a\7\62\2\2\u0a8a\u0a8b\7=\2\2\u0a8b\u0a8c\5.\30",
    "\2\u0a8c\u0a8d\7>\2\2\u0a8d\u0a8e\7Y\2\2\u0a8e\u0a8f\7\2\2\3\u0a8f\u0ab0",
    "\3\2\2\2\u0a90\u0a91\7\36\2\2\u0a91\u0a93\7=\2\2\u0a92\u0a94\5.\30\2",
    "\u0a93\u0a92\3\2\2\2\u0a93\u0a94\3\2\2\2\u0a94\u0a95\3\2\2\2\u0a95\u0a97",
    "\7Y\2\2\u0a96\u0a98\5.\30\2\u0a97\u0a96\3\2\2\2\u0a97\u0a98\3\2\2\2",
    "\u0a98\u0a99\3\2\2\2\u0a99\u0a9b\7Y\2\2\u0a9a\u0a9c\5.\30\2\u0a9b\u0a9a",
    "\3\2\2\2\u0a9b\u0a9c\3\2\2\2\u0a9c\u0a9d\3\2\2\2\u0a9d\u0a9e\7>\2\2",
    "\u0a9e\u0a9f\5\u0090I\2\u0a9f\u0aa0\7\2\2\3\u0aa0\u0ab0\3\2\2\2\u0aa1",
    "\u0aa2\7\36\2\2\u0aa2\u0aa3\7=\2\2\u0aa3\u0aa5\5\62\32\2\u0aa4\u0aa6",
    "\5.\30\2\u0aa5\u0aa4\3\2\2\2\u0aa5\u0aa6\3\2\2\2\u0aa6\u0aa7\3\2\2\2",
    "\u0aa7\u0aa9\7Y\2\2\u0aa8\u0aaa\5.\30\2\u0aa9\u0aa8\3\2\2\2\u0aa9\u0aaa",
    "\3\2\2\2\u0aaa\u0aab\3\2\2\2\u0aab\u0aac\7>\2\2\u0aac\u0aad\5\u0090",
    "I\2\u0aad\u0aae\7\2\2\3\u0aae\u0ab0\3\2\2\2\u0aaf\u0a80\3\2\2\2\u0aaf",
    "\u0a87\3\2\2\2\u0aaf\u0a90\3\2\2\2\u0aaf\u0aa1\3\2\2\2\u0ab0\u014d\3",
    "\2\2\2\u0ab1\u0ab2\7\37\2\2\u0ab2\u0ab3\7k\2\2\u0ab3\u0ab4\7Y\2\2\u0ab4",
    "\u0ac6\7\2\2\3\u0ab5\u0ab6\7\26\2\2\u0ab6\u0ab7\7Y\2\2\u0ab7\u0ac6\7",
    "\2\2\3\u0ab8\u0ab9\7\22\2\2\u0ab9\u0aba\7Y\2\2\u0aba\u0ac6\7\2\2\3\u0abb",
    "\u0abd\7&\2\2\u0abc\u0abe\5.\30\2\u0abd\u0abc\3\2\2\2\u0abd\u0abe\3",
    "\2\2\2\u0abe\u0abf\3\2\2\2\u0abf\u0ac0\7Y\2\2\u0ac0\u0ac6\7\2\2\3\u0ac1",
    "\u0ac2\7\37\2\2\u0ac2\u0ac3\5\16\b\2\u0ac3\u0ac4\7Y\2\2\u0ac4\u0ac6",
    "\3\2\2\2\u0ac5\u0ab1\3\2\2\2\u0ac5\u0ab5\3\2\2\2\u0ac5\u0ab8\3\2\2\2",
    "\u0ac5\u0abb\3\2\2\2\u0ac5\u0ac1\3\2\2\2\u0ac6\u014f\3\2\2\2\u0ac7\u0ac9",
    "\5\u00a6T\2\u0ac8\u0ac7\3\2\2\2\u0ac8\u0ac9\3\2\2\2\u0ac9\u0aca\3\2",
    "\2\2\u0aca\u0acd\7\2\2\3\u0acb\u0acd\7\2\2\3\u0acc\u0ac8\3\2\2\2\u0acc",
    "\u0acb\3\2\2\2\u0acd\u0151\3\2\2\2\u0ace\u0acf\5\u00a8U\2\u0acf\u0ad0",
    "\7\2\2\3\u0ad0\u0ad6\3\2\2\2\u0ad1\u0ad2\5\u00a6T\2\u0ad2\u0ad3\5\u00a8",
    "U\2\u0ad3\u0ad4\7\2\2\3\u0ad4\u0ad6\3\2\2\2\u0ad5\u0ace\3\2\2\2\u0ad5",
    "\u0ad1\3\2\2\2\u0ad6\u0153\3\2\2\2\u0ad7\u0ad8\5\u00aaV\2\u0ad8\u0ad9",
    "\7\2\2\3\u0ad9\u0adf\3\2\2\2\u0ada\u0adb\5\62\32\2\u0adb\u0adc\7\2\2",
    "\3\u0adc\u0adf\3\2\2\2\u0add\u0adf\7Y\2\2\u0ade\u0ad7\3\2\2\2\u0ade",
    "\u0ada\3\2\2\2\u0ade\u0add\3\2\2\2\u0adf\u0155\3\2\2\2\u0ae0\u0ae2\5",
    "\64\33\2\u0ae1\u0ae0\3\2\2\2\u0ae1\u0ae2\3\2\2\2\u0ae2\u0ae3\3\2\2\2",
    "\u0ae3\u0ae5\5b\62\2\u0ae4\u0ae6\5\u00acW\2\u0ae5\u0ae4\3\2\2\2\u0ae5",
    "\u0ae6\3\2\2\2\u0ae6\u0ae7\3\2\2\2\u0ae7\u0ae8\5\u0094K\2\u0ae8\u0ae9",
    "\7\2\2\3\u0ae9\u0157\3\2\2\2\u0aea\u0aeb\5\62\32\2\u0aeb\u0aec\7\2\2",
    "\3\u0aec\u0af2\3\2\2\2\u0aed\u0aee\5\u00acW\2\u0aee\u0aef\5\62\32\2",
    "\u0aef\u0af0\7\2\2\3\u0af0\u0af2\3\2\2\2\u0af1\u0aea\3\2\2\2\u0af1\u0aed",
    "\3\2\2\2\u0af2\u0159\3\2\2\2\u0114\u015f\u0167\u017b\u018c\u0196\u01ba",
    "\u01c4\u01d1\u01d3\u01de\u01f7\u0207\u0215\u0217\u0223\u0225\u0231\u0233",
    "\u0245\u0247\u0253\u0255\u0260\u026b\u0276\u0281\u028c\u0295\u029c\u02a8",
    "\u02af\u02b4\u02b9\u02be\u02c5\u02cf\u02d7\u02e9\u02ed\u02f4\u0303\u0308",
    "\u030d\u0311\u0315\u0317\u0321\u0326\u032a\u032e\u0336\u033f\u0349\u0351",
    "\u0362\u036e\u0371\u0377\u0380\u0385\u0388\u038f\u039e\u03aa\u03ad\u03af",
    "\u03b7\u03bb\u03c9\u03cd\u03d2\u03d5\u03d8\u03df\u03e1\u03e6\u03ea\u03ef",
    "\u03f3\u03f6\u03ff\u0407\u0411\u0419\u041b\u0425\u042a\u042e\u0434\u0437",
    "\u0440\u0445\u0448\u044e\u045e\u0464\u0467\u046c\u046f\u0476\u0489\u048f",
    "\u0492\u0494\u04a3\u04a7\u04ae\u04b3\u04c0\u04c9\u04d2\u04e5\u04e8\u04f0",
    "\u04f3\u04f7\u04fc\u0509\u050d\u0518\u051e\u0527\u0532\u053a\u054d\u0551",
    "\u0555\u055d\u0561\u0566\u0571\u0578\u057b\u057f\u0588\u058e\u0591\u0595",
    "\u05a0\u05aa\u05b6\u05cc\u05de\u05ea\u05f8\u0633\u063d\u0660\u0669\u067b",
    "\u068f\u069e\u06ad\u06c6\u06d5\u06df\u06e9\u06f3\u06fd\u0707\u070f\u071b",
    "\u0729\u0733\u073a\u0742\u0747\u074e\u0761\u076b\u0775\u0783\u07a0\u07b9",
    "\u07bd\u07c6\u07cc\u07da\u07de\u07e6\u07ea\u07f0\u07f4\u07fe\u0804\u080a",
    "\u080e\u0817\u0822\u082c\u0836\u0849\u0851\u085c\u086a\u086d\u0873\u0882",
    "\u0885\u088e\u089f\u08ae\u08b3\u08ba\u08c1\u08d0\u08d6\u08db\u08de\u08e1",
    "\u08ea\u08ec\u08f1\u08f6\u08fd\u0901\u0904\u090d\u0917\u0921\u0929\u092d",
    "\u0936\u093a\u0942\u0948\u094d\u0955\u095c\u095f\u0966\u0979\u097f\u0986",
    "\u0989\u0992\u09a9\u09af\u09b4\u09c7\u09ca\u09d2\u09d7\u09e4\u09ee\u09f7",
    "\u0a17\u0a1a\u0a22\u0a25\u0a29\u0a2f\u0a41\u0a45\u0a51\u0a5d\u0a67\u0a73",
    "\u0a7e\u0a93\u0a97\u0a9b\u0aa5\u0aa9\u0aaf\u0abd\u0ac5\u0ac8\u0acc\u0ad5",
    "\u0ade\u0ae1\u0ae5\u0af1"].join("");


var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN);

var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); });

var sharedContextCache = new antlr4.PredictionContextCache();

var literalNames = [ 'null', "'__extension__'", "'__builtin_va_arg'", "'__builtin_offsetof'", 
                     "'__m128'", "'__m128d'", "'__m128i'", "'__typeof__'", 
                     "'__inline__'", "'__stdcall'", "'__declspec'", "'__asm'", 
                     "'__attribute__'", "'__asm__'", "'__volatile__'", "'auto'", 
                     "'break'", "'case'", "'char'", "'const'", "'continue'", 
                     "'default'", "'do'", "'double'", "'else'", "'enum'", 
                     "'extern'", "'float'", "'for'", "'goto'", "'if'", "'inline'", 
                     "'int'", "'long'", "'register'", "'restrict'", "'return'", 
                     "'short'", "'signed'", "'sizeof'", "'static'", "'struct'", 
                     "'switch'", "'typedef'", "'union'", "'unsigned'", "'void'", 
                     "'volatile'", "'while'", "'_Alignas'", "'_Alignof'", 
                     "'_Atomic'", "'_Bool'", "'_Complex'", "'_Generic'", 
                     "'_Imaginary'", "'_Noreturn'", "'_Static_assert'", 
                     "'_Thread_local'", "'('", "')'", "'['", "']'", "'{'", 
                     "'}'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", 
                     "'+'", "'++'", "'-'", "'--'", "'*'", "'/'", "'%'", 
                     "'&'", "'|'", "'&&'", "'||'", "'^'", "'!'", "'~'", 
                     "'?'", "':'", "';'", "','", "'='", "'*='", "'/='", 
                     "'%='", "'+='", "'-='", "'<<='", "'>>='", "'&='", "'^='", 
                     "'|='", "'=='", "'!='", "'->'", "'.'", "'...'" ];

var symbolicNames = [ 'null', 'null', 'null', 'null', 'null', 'null', 'null', 
                      'null', 'null', 'null', 'null', 'null', 'null', 'null', 
                      'null', "Auto", "Break", "Case", "Char", "Const", 
                      "Continue", "Default", "Do", "Double", "Else", "Enum", 
                      "Extern", "Float", "For", "Goto", "If", "Inline", 
                      "Int", "Long", "Register", "Restrict", "Return", "Short", 
                      "Signed", "Sizeof", "Static", "Struct", "Switch", 
                      "Typedef", "Union", "Unsigned", "Void", "Volatile", 
                      "While", "Alignas", "Alignof", "Atomic", "Bool", "Complex", 
                      "Generic", "Imaginary", "Noreturn", "StaticAssert", 
                      "ThreadLocal", "LeftParen", "RightParen", "LeftBracket", 
                      "RightBracket", "LeftBrace", "RightBrace", "Less", 
                      "LessEqual", "Greater", "GreaterEqual", "LeftShift", 
                      "RightShift", "Plus", "PlusPlus", "Minus", "MinusMinus", 
                      "Star", "Div", "Mod", "And", "Or", "AndAnd", "OrOr", 
                      "Caret", "Not", "Tilde", "Question", "Colon", "Semi", 
                      "Comma", "Assign", "StarAssign", "DivAssign", "ModAssign", 
                      "PlusAssign", "MinusAssign", "LeftShiftAssign", "RightShiftAssign", 
                      "AndAssign", "XorAssign", "OrAssign", "Equal", "NotEqual", 
                      "Arrow", "Dot", "Ellipsis", "Identifier", "Constant", 
                      "StringLiteral", "Directive", "Whitespace", "Newline", 
                      "BlockComment", "LineComment" ];

var ruleNames =  [ "primaryExpression", "genericSelection", "genericAssocList", 
                   "genericAssociation", "postfixExpression", "argumentExpressionList", 
                   "unaryExpression", "unaryOperator", "castExpression", 
                   "multiplicativeExpression", "additiveExpression", "shiftExpression", 
                   "relationalExpression", "equalityExpression", "andExpression", 
                   "exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression", 
                   "logicalOrExpression", "conditionalExpression", "assignmentExpression", 
                   "assignmentOperator", "expression", "constantExpression", 
                   "declaration", "declarationSpecifiers", "declarationSpecifiers2", 
                   "declarationSpecifier", "initDeclaratorList", "initDeclarator", 
                   "storageClassSpecifier", "typeSpecifier", "structOrUnionSpecifier", 
                   "structOrUnion", "structDeclarationsBlock", "structDeclarationList", 
                   "structDeclaration", "specifierQualifierList", "structDeclaratorList", 
                   "structDeclarator", "enumSpecifier", "enumeratorList", 
                   "enumerator", "enumerationConstant", "atomicTypeSpecifier", 
                   "typeQualifier", "functionSpecifier", "alignmentSpecifier", 
                   "declarator", "directDeclarator", "gccDeclaratorExtension", 
                   "gccAttributeSpecifier", "gccAttributeList", "gccAttribute", 
                   "nestedParenthesesBlock", "pointer", "typeQualifierList", 
                   "parameterTypeList", "parameterList", "parameterDeclaration", 
                   "identifierList", "typeName", "abstractDeclarator", "directAbstractDeclarator", 
                   "typedefName", "initializer", "initializerList", "designation", 
                   "designatorList", "designator", "staticAssertDeclaration", 
                   "statement", "labeledStatement", "compoundStatement", 
                   "blockItemList", "blockItem", "specialMethodCall", "expressionStatement", 
                   "selectionStatement", "iterationStatement", "jumpStatement", 
                   "compilationUnit", "translationUnit", "externalDeclaration", 
                   "functionDefinition", "declarationList", "primaryExpression_DropletFile", 
                   "genericSelection_DropletFile", "genericAssocList_DropletFile", 
                   "genericAssociation_DropletFile", "postfixExpression_DropletFile", 
                   "argumentExpressionList_DropletFile", "unaryExpression_DropletFile", 
                   "unaryOperator_DropletFile", "castExpression_DropletFile", 
                   "multiplicativeExpression_DropletFile", "additiveExpression_DropletFile", 
                   "shiftExpression_DropletFile", "relationalExpression_DropletFile", 
                   "equalityExpression_DropletFile", "andExpression_DropletFile", 
                   "exclusiveOrExpression_DropletFile", "inclusiveOrExpression_DropletFile", 
                   "logicalAndExpression_DropletFile", "logicalOrExpression_DropletFile", 
                   "conditionalExpression_DropletFile", "assignmentExpression_DropletFile", 
                   "assignmentOperator_DropletFile", "expression_DropletFile", 
                   "constantExpression_DropletFile", "declaration_DropletFile", 
                   "declarationSpecifiers_DropletFile", "declarationSpecifiers2_DropletFile", 
                   "declarationSpecifier_DropletFile", "initDeclaratorList_DropletFile", 
                   "initDeclarator_DropletFile", "storageClassSpecifier_DropletFile", 
                   "typeSpecifier_DropletFile", "structOrUnionSpecifier_DropletFile", 
                   "structOrUnion_DropletFile", "structDeclarationsBlock_DropletFile", 
                   "structDeclarationList_DropletFile", "structDeclaration_DropletFile", 
                   "specifierQualifierList_DropletFile", "structDeclaratorList_DropletFile", 
                   "structDeclarator_DropletFile", "enumSpecifier_DropletFile", 
                   "enumeratorList_DropletFile", "enumerator_DropletFile", 
                   "enumerationConstant_DropletFile", "atomicTypeSpecifier_DropletFile", 
                   "typeQualifier_DropletFile", "functionSpecifier_DropletFile", 
                   "alignmentSpecifier_DropletFile", "declarator_DropletFile", 
                   "directDeclarator_DropletFile", "gccDeclaratorExtension_DropletFile", 
                   "gccAttributeSpecifier_DropletFile", "gccAttributeList_DropletFile", 
                   "gccAttribute_DropletFile", "nestedParenthesesBlock_DropletFile", 
                   "pointer_DropletFile", "typeQualifierList_DropletFile", 
                   "parameterTypeList_DropletFile", "parameterList_DropletFile", 
                   "parameterDeclaration_DropletFile", "identifierList_DropletFile", 
                   "typeName_DropletFile", "abstractDeclarator_DropletFile", 
                   "directAbstractDeclarator_DropletFile", "typedefName_DropletFile", 
                   "initializer_DropletFile", "initializerList_DropletFile", 
                   "designation_DropletFile", "designatorList_DropletFile", 
                   "designator_DropletFile", "staticAssertDeclaration_DropletFile", 
                   "statement_DropletFile", "labeledStatement_DropletFile", 
                   "compoundStatement_DropletFile", "blockItemList_DropletFile", 
                   "blockItem_DropletFile", "specialMethodCall_DropletFile", 
                   "expressionStatement_DropletFile", "selectionStatement_DropletFile", 
                   "iterationStatement_DropletFile", "jumpStatement_DropletFile", 
                   "compilationUnit_DropletFile", "translationUnit_DropletFile", 
                   "externalDeclaration_DropletFile", "functionDefinition_DropletFile", 
                   "declarationList_DropletFile" ];

function CParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

CParser.prototype = Object.create(antlr4.Parser.prototype);
CParser.prototype.constructor = CParser;

Object.defineProperty(CParser.prototype, "atn", {
	get : function() {
		return atn;
	}
});

CParser.EOF = antlr4.Token.EOF;
CParser.T__0 = 1;
CParser.T__1 = 2;
CParser.T__2 = 3;
CParser.T__3 = 4;
CParser.T__4 = 5;
CParser.T__5 = 6;
CParser.T__6 = 7;
CParser.T__7 = 8;
CParser.T__8 = 9;
CParser.T__9 = 10;
CParser.T__10 = 11;
CParser.T__11 = 12;
CParser.T__12 = 13;
CParser.T__13 = 14;
CParser.Auto = 15;
CParser.Break = 16;
CParser.Case = 17;
CParser.Char = 18;
CParser.Const = 19;
CParser.Continue = 20;
CParser.Default = 21;
CParser.Do = 22;
CParser.Double = 23;
CParser.Else = 24;
CParser.Enum = 25;
CParser.Extern = 26;
CParser.Float = 27;
CParser.For = 28;
CParser.Goto = 29;
CParser.If = 30;
CParser.Inline = 31;
CParser.Int = 32;
CParser.Long = 33;
CParser.Register = 34;
CParser.Restrict = 35;
CParser.Return = 36;
CParser.Short = 37;
CParser.Signed = 38;
CParser.Sizeof = 39;
CParser.Static = 40;
CParser.Struct = 41;
CParser.Switch = 42;
CParser.Typedef = 43;
CParser.Union = 44;
CParser.Unsigned = 45;
CParser.Void = 46;
CParser.Volatile = 47;
CParser.While = 48;
CParser.Alignas = 49;
CParser.Alignof = 50;
CParser.Atomic = 51;
CParser.Bool = 52;
CParser.Complex = 53;
CParser.Generic = 54;
CParser.Imaginary = 55;
CParser.Noreturn = 56;
CParser.StaticAssert = 57;
CParser.ThreadLocal = 58;
CParser.LeftParen = 59;
CParser.RightParen = 60;
CParser.LeftBracket = 61;
CParser.RightBracket = 62;
CParser.LeftBrace = 63;
CParser.RightBrace = 64;
CParser.Less = 65;
CParser.LessEqual = 66;
CParser.Greater = 67;
CParser.GreaterEqual = 68;
CParser.LeftShift = 69;
CParser.RightShift = 70;
CParser.Plus = 71;
CParser.PlusPlus = 72;
CParser.Minus = 73;
CParser.MinusMinus = 74;
CParser.Star = 75;
CParser.Div = 76;
CParser.Mod = 77;
CParser.And = 78;
CParser.Or = 79;
CParser.AndAnd = 80;
CParser.OrOr = 81;
CParser.Caret = 82;
CParser.Not = 83;
CParser.Tilde = 84;
CParser.Question = 85;
CParser.Colon = 86;
CParser.Semi = 87;
CParser.Comma = 88;
CParser.Assign = 89;
CParser.StarAssign = 90;
CParser.DivAssign = 91;
CParser.ModAssign = 92;
CParser.PlusAssign = 93;
CParser.MinusAssign = 94;
CParser.LeftShiftAssign = 95;
CParser.RightShiftAssign = 96;
CParser.AndAssign = 97;
CParser.XorAssign = 98;
CParser.OrAssign = 99;
CParser.Equal = 100;
CParser.NotEqual = 101;
CParser.Arrow = 102;
CParser.Dot = 103;
CParser.Ellipsis = 104;
CParser.Identifier = 105;
CParser.Constant = 106;
CParser.StringLiteral = 107;
CParser.Directive = 108;
CParser.Whitespace = 109;
CParser.Newline = 110;
CParser.BlockComment = 111;
CParser.LineComment = 112;

CParser.RULE_primaryExpression = 0;
CParser.RULE_genericSelection = 1;
CParser.RULE_genericAssocList = 2;
CParser.RULE_genericAssociation = 3;
CParser.RULE_postfixExpression = 4;
CParser.RULE_argumentExpressionList = 5;
CParser.RULE_unaryExpression = 6;
CParser.RULE_unaryOperator = 7;
CParser.RULE_castExpression = 8;
CParser.RULE_multiplicativeExpression = 9;
CParser.RULE_additiveExpression = 10;
CParser.RULE_shiftExpression = 11;
CParser.RULE_relationalExpression = 12;
CParser.RULE_equalityExpression = 13;
CParser.RULE_andExpression = 14;
CParser.RULE_exclusiveOrExpression = 15;
CParser.RULE_inclusiveOrExpression = 16;
CParser.RULE_logicalAndExpression = 17;
CParser.RULE_logicalOrExpression = 18;
CParser.RULE_conditionalExpression = 19;
CParser.RULE_assignmentExpression = 20;
CParser.RULE_assignmentOperator = 21;
CParser.RULE_expression = 22;
CParser.RULE_constantExpression = 23;
CParser.RULE_declaration = 24;
CParser.RULE_declarationSpecifiers = 25;
CParser.RULE_declarationSpecifiers2 = 26;
CParser.RULE_declarationSpecifier = 27;
CParser.RULE_initDeclaratorList = 28;
CParser.RULE_initDeclarator = 29;
CParser.RULE_storageClassSpecifier = 30;
CParser.RULE_typeSpecifier = 31;
CParser.RULE_structOrUnionSpecifier = 32;
CParser.RULE_structOrUnion = 33;
CParser.RULE_structDeclarationsBlock = 34;
CParser.RULE_structDeclarationList = 35;
CParser.RULE_structDeclaration = 36;
CParser.RULE_specifierQualifierList = 37;
CParser.RULE_structDeclaratorList = 38;
CParser.RULE_structDeclarator = 39;
CParser.RULE_enumSpecifier = 40;
CParser.RULE_enumeratorList = 41;
CParser.RULE_enumerator = 42;
CParser.RULE_enumerationConstant = 43;
CParser.RULE_atomicTypeSpecifier = 44;
CParser.RULE_typeQualifier = 45;
CParser.RULE_functionSpecifier = 46;
CParser.RULE_alignmentSpecifier = 47;
CParser.RULE_declarator = 48;
CParser.RULE_directDeclarator = 49;
CParser.RULE_gccDeclaratorExtension = 50;
CParser.RULE_gccAttributeSpecifier = 51;
CParser.RULE_gccAttributeList = 52;
CParser.RULE_gccAttribute = 53;
CParser.RULE_nestedParenthesesBlock = 54;
CParser.RULE_pointer = 55;
CParser.RULE_typeQualifierList = 56;
CParser.RULE_parameterTypeList = 57;
CParser.RULE_parameterList = 58;
CParser.RULE_parameterDeclaration = 59;
CParser.RULE_identifierList = 60;
CParser.RULE_typeName = 61;
CParser.RULE_abstractDeclarator = 62;
CParser.RULE_directAbstractDeclarator = 63;
CParser.RULE_typedefName = 64;
CParser.RULE_initializer = 65;
CParser.RULE_initializerList = 66;
CParser.RULE_designation = 67;
CParser.RULE_designatorList = 68;
CParser.RULE_designator = 69;
CParser.RULE_staticAssertDeclaration = 70;
CParser.RULE_statement = 71;
CParser.RULE_labeledStatement = 72;
CParser.RULE_compoundStatement = 73;
CParser.RULE_blockItemList = 74;
CParser.RULE_blockItem = 75;
CParser.RULE_specialMethodCall = 76;
CParser.RULE_expressionStatement = 77;
CParser.RULE_selectionStatement = 78;
CParser.RULE_iterationStatement = 79;
CParser.RULE_jumpStatement = 80;
CParser.RULE_compilationUnit = 81;
CParser.RULE_translationUnit = 82;
CParser.RULE_externalDeclaration = 83;
CParser.RULE_functionDefinition = 84;
CParser.RULE_declarationList = 85;
CParser.RULE_primaryExpression_DropletFile = 86;
CParser.RULE_genericSelection_DropletFile = 87;
CParser.RULE_genericAssocList_DropletFile = 88;
CParser.RULE_genericAssociation_DropletFile = 89;
CParser.RULE_postfixExpression_DropletFile = 90;
CParser.RULE_argumentExpressionList_DropletFile = 91;
CParser.RULE_unaryExpression_DropletFile = 92;
CParser.RULE_unaryOperator_DropletFile = 93;
CParser.RULE_castExpression_DropletFile = 94;
CParser.RULE_multiplicativeExpression_DropletFile = 95;
CParser.RULE_additiveExpression_DropletFile = 96;
CParser.RULE_shiftExpression_DropletFile = 97;
CParser.RULE_relationalExpression_DropletFile = 98;
CParser.RULE_equalityExpression_DropletFile = 99;
CParser.RULE_andExpression_DropletFile = 100;
CParser.RULE_exclusiveOrExpression_DropletFile = 101;
CParser.RULE_inclusiveOrExpression_DropletFile = 102;
CParser.RULE_logicalAndExpression_DropletFile = 103;
CParser.RULE_logicalOrExpression_DropletFile = 104;
CParser.RULE_conditionalExpression_DropletFile = 105;
CParser.RULE_assignmentExpression_DropletFile = 106;
CParser.RULE_assignmentOperator_DropletFile = 107;
CParser.RULE_expression_DropletFile = 108;
CParser.RULE_constantExpression_DropletFile = 109;
CParser.RULE_declaration_DropletFile = 110;
CParser.RULE_declarationSpecifiers_DropletFile = 111;
CParser.RULE_declarationSpecifiers2_DropletFile = 112;
CParser.RULE_declarationSpecifier_DropletFile = 113;
CParser.RULE_initDeclaratorList_DropletFile = 114;
CParser.RULE_initDeclarator_DropletFile = 115;
CParser.RULE_storageClassSpecifier_DropletFile = 116;
CParser.RULE_typeSpecifier_DropletFile = 117;
CParser.RULE_structOrUnionSpecifier_DropletFile = 118;
CParser.RULE_structOrUnion_DropletFile = 119;
CParser.RULE_structDeclarationsBlock_DropletFile = 120;
CParser.RULE_structDeclarationList_DropletFile = 121;
CParser.RULE_structDeclaration_DropletFile = 122;
CParser.RULE_specifierQualifierList_DropletFile = 123;
CParser.RULE_structDeclaratorList_DropletFile = 124;
CParser.RULE_structDeclarator_DropletFile = 125;
CParser.RULE_enumSpecifier_DropletFile = 126;
CParser.RULE_enumeratorList_DropletFile = 127;
CParser.RULE_enumerator_DropletFile = 128;
CParser.RULE_enumerationConstant_DropletFile = 129;
CParser.RULE_atomicTypeSpecifier_DropletFile = 130;
CParser.RULE_typeQualifier_DropletFile = 131;
CParser.RULE_functionSpecifier_DropletFile = 132;
CParser.RULE_alignmentSpecifier_DropletFile = 133;
CParser.RULE_declarator_DropletFile = 134;
CParser.RULE_directDeclarator_DropletFile = 135;
CParser.RULE_gccDeclaratorExtension_DropletFile = 136;
CParser.RULE_gccAttributeSpecifier_DropletFile = 137;
CParser.RULE_gccAttributeList_DropletFile = 138;
CParser.RULE_gccAttribute_DropletFile = 139;
CParser.RULE_nestedParenthesesBlock_DropletFile = 140;
CParser.RULE_pointer_DropletFile = 141;
CParser.RULE_typeQualifierList_DropletFile = 142;
CParser.RULE_parameterTypeList_DropletFile = 143;
CParser.RULE_parameterList_DropletFile = 144;
CParser.RULE_parameterDeclaration_DropletFile = 145;
CParser.RULE_identifierList_DropletFile = 146;
CParser.RULE_typeName_DropletFile = 147;
CParser.RULE_abstractDeclarator_DropletFile = 148;
CParser.RULE_directAbstractDeclarator_DropletFile = 149;
CParser.RULE_typedefName_DropletFile = 150;
CParser.RULE_initializer_DropletFile = 151;
CParser.RULE_initializerList_DropletFile = 152;
CParser.RULE_designation_DropletFile = 153;
CParser.RULE_designatorList_DropletFile = 154;
CParser.RULE_designator_DropletFile = 155;
CParser.RULE_staticAssertDeclaration_DropletFile = 156;
CParser.RULE_statement_DropletFile = 157;
CParser.RULE_labeledStatement_DropletFile = 158;
CParser.RULE_compoundStatement_DropletFile = 159;
CParser.RULE_blockItemList_DropletFile = 160;
CParser.RULE_blockItem_DropletFile = 161;
CParser.RULE_specialMethodCall_DropletFile = 162;
CParser.RULE_expressionStatement_DropletFile = 163;
CParser.RULE_selectionStatement_DropletFile = 164;
CParser.RULE_iterationStatement_DropletFile = 165;
CParser.RULE_jumpStatement_DropletFile = 166;
CParser.RULE_compilationUnit_DropletFile = 167;
CParser.RULE_translationUnit_DropletFile = 168;
CParser.RULE_externalDeclaration_DropletFile = 169;
CParser.RULE_functionDefinition_DropletFile = 170;
CParser.RULE_declarationList_DropletFile = 171;

function PrimaryExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_primaryExpression;
    return this;
}

PrimaryExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
PrimaryExpressionContext.prototype.constructor = PrimaryExpressionContext;

PrimaryExpressionContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

PrimaryExpressionContext.prototype.Constant = function() {
    return this.getToken(CParser.Constant, 0);
};

PrimaryExpressionContext.prototype.StringLiteral = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.StringLiteral);
    } else {
        return this.getToken(CParser.StringLiteral, i);
    }
};


PrimaryExpressionContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

PrimaryExpressionContext.prototype.genericSelection = function() {
    return this.getTypedRuleContext(GenericSelectionContext,0);
};

PrimaryExpressionContext.prototype.compoundStatement = function() {
    return this.getTypedRuleContext(CompoundStatementContext,0);
};

PrimaryExpressionContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

PrimaryExpressionContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

PrimaryExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterPrimaryExpression(this);
	}
};

PrimaryExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitPrimaryExpression(this);
	}
};




CParser.PrimaryExpressionContext = PrimaryExpressionContext;

CParser.prototype.primaryExpression = function() {

    var localctx = new PrimaryExpressionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 0, CParser.RULE_primaryExpression);
    var _la = 0; // Token type
    try {
        this.state = 377;
        var la_ = this._interp.adaptivePredict(this._input,2,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 344;
            this.match(CParser.Identifier);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 345;
            this.match(CParser.Constant);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 347; 
            this._errHandler.sync(this);
            var _alt = 1;
            do {
            	switch (_alt) {
            	case 1:
            		this.state = 346;
            		this.match(CParser.StringLiteral);
            		break;
            	default:
            		throw new antlr4.error.NoViableAltException(this);
            	}
            	this.state = 349; 
            	this._errHandler.sync(this);
            	_alt = this._interp.adaptivePredict(this._input,0, this._ctx);
            } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER );
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 351;
            this.match(CParser.LeftParen);
            this.state = 352;
            this.expression(0);
            this.state = 353;
            this.match(CParser.RightParen);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 355;
            this.genericSelection();
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 357;
            _la = this._input.LA(1);
            if(_la===CParser.T__0) {
                this.state = 356;
                this.match(CParser.T__0);
            }

            this.state = 359;
            this.match(CParser.LeftParen);
            this.state = 360;
            this.compoundStatement();
            this.state = 361;
            this.match(CParser.RightParen);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 363;
            this.match(CParser.T__1);
            this.state = 364;
            this.match(CParser.LeftParen);
            this.state = 365;
            this.unaryExpression();
            this.state = 366;
            this.match(CParser.Comma);
            this.state = 367;
            this.typeName();
            this.state = 368;
            this.match(CParser.RightParen);
            break;

        case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 370;
            this.match(CParser.T__2);
            this.state = 371;
            this.match(CParser.LeftParen);
            this.state = 372;
            this.typeName();
            this.state = 373;
            this.match(CParser.Comma);
            this.state = 374;
            this.unaryExpression();
            this.state = 375;
            this.match(CParser.RightParen);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GenericSelectionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_genericSelection;
    return this;
}

GenericSelectionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GenericSelectionContext.prototype.constructor = GenericSelectionContext;

GenericSelectionContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

GenericSelectionContext.prototype.genericAssocList = function() {
    return this.getTypedRuleContext(GenericAssocListContext,0);
};

GenericSelectionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGenericSelection(this);
	}
};

GenericSelectionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGenericSelection(this);
	}
};




CParser.GenericSelectionContext = GenericSelectionContext;

CParser.prototype.genericSelection = function() {

    var localctx = new GenericSelectionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 2, CParser.RULE_genericSelection);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 379;
        this.match(CParser.Generic);
        this.state = 380;
        this.match(CParser.LeftParen);
        this.state = 381;
        this.assignmentExpression();
        this.state = 382;
        this.match(CParser.Comma);
        this.state = 383;
        this.genericAssocList(0);
        this.state = 384;
        this.match(CParser.RightParen);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GenericAssocListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_genericAssocList;
    return this;
}

GenericAssocListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GenericAssocListContext.prototype.constructor = GenericAssocListContext;

GenericAssocListContext.prototype.genericAssociation = function() {
    return this.getTypedRuleContext(GenericAssociationContext,0);
};

GenericAssocListContext.prototype.genericAssocList = function() {
    return this.getTypedRuleContext(GenericAssocListContext,0);
};

GenericAssocListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGenericAssocList(this);
	}
};

GenericAssocListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGenericAssocList(this);
	}
};



CParser.prototype.genericAssocList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new GenericAssocListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 4;
    this.enterRecursionRule(localctx, 4, CParser.RULE_genericAssocList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 387;
        this.genericAssociation();
        this._ctx.stop = this._input.LT(-1);
        this.state = 394;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,3,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new GenericAssocListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_genericAssocList);
                this.state = 389;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 390;
                this.match(CParser.Comma);
                this.state = 391;
                this.genericAssociation(); 
            }
            this.state = 396;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,3,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function GenericAssociationContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_genericAssociation;
    return this;
}

GenericAssociationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GenericAssociationContext.prototype.constructor = GenericAssociationContext;

GenericAssociationContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

GenericAssociationContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

GenericAssociationContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGenericAssociation(this);
	}
};

GenericAssociationContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGenericAssociation(this);
	}
};




CParser.GenericAssociationContext = GenericAssociationContext;

CParser.prototype.genericAssociation = function() {

    var localctx = new GenericAssociationContext(this, this._ctx, this.state);
    this.enterRule(localctx, 6, CParser.RULE_genericAssociation);
    try {
        this.state = 404;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.Char:
        case CParser.Const:
        case CParser.Double:
        case CParser.Enum:
        case CParser.Float:
        case CParser.Int:
        case CParser.Long:
        case CParser.Restrict:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Struct:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 397;
            this.typeName();
            this.state = 398;
            this.match(CParser.Colon);
            this.state = 399;
            this.assignmentExpression();
            break;
        case CParser.Default:
            this.enterOuterAlt(localctx, 2);
            this.state = 401;
            this.match(CParser.Default);
            this.state = 402;
            this.match(CParser.Colon);
            this.state = 403;
            this.assignmentExpression();
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function PostfixExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_postfixExpression;
    return this;
}

PostfixExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
PostfixExpressionContext.prototype.constructor = PostfixExpressionContext;

PostfixExpressionContext.prototype.primaryExpression = function() {
    return this.getTypedRuleContext(PrimaryExpressionContext,0);
};

PostfixExpressionContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

PostfixExpressionContext.prototype.initializerList = function() {
    return this.getTypedRuleContext(InitializerListContext,0);
};

PostfixExpressionContext.prototype.postfixExpression = function() {
    return this.getTypedRuleContext(PostfixExpressionContext,0);
};

PostfixExpressionContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

PostfixExpressionContext.prototype.argumentExpressionList = function() {
    return this.getTypedRuleContext(ArgumentExpressionListContext,0);
};

PostfixExpressionContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

PostfixExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterPostfixExpression(this);
	}
};

PostfixExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitPostfixExpression(this);
	}
};



CParser.prototype.postfixExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new PostfixExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 8;
    this.enterRecursionRule(localctx, 8, CParser.RULE_postfixExpression, _p);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 440;
        var la_ = this._interp.adaptivePredict(this._input,5,this._ctx);
        switch(la_) {
        case 1:
            this.state = 407;
            this.primaryExpression();
            break;

        case 2:
            this.state = 408;
            this.match(CParser.LeftParen);
            this.state = 409;
            this.typeName();
            this.state = 410;
            this.match(CParser.RightParen);
            this.state = 411;
            this.match(CParser.LeftBrace);
            this.state = 412;
            this.initializerList(0);
            this.state = 413;
            this.match(CParser.RightBrace);
            break;

        case 3:
            this.state = 415;
            this.match(CParser.LeftParen);
            this.state = 416;
            this.typeName();
            this.state = 417;
            this.match(CParser.RightParen);
            this.state = 418;
            this.match(CParser.LeftBrace);
            this.state = 419;
            this.initializerList(0);
            this.state = 420;
            this.match(CParser.Comma);
            this.state = 421;
            this.match(CParser.RightBrace);
            break;

        case 4:
            this.state = 423;
            this.match(CParser.T__0);
            this.state = 424;
            this.match(CParser.LeftParen);
            this.state = 425;
            this.typeName();
            this.state = 426;
            this.match(CParser.RightParen);
            this.state = 427;
            this.match(CParser.LeftBrace);
            this.state = 428;
            this.initializerList(0);
            this.state = 429;
            this.match(CParser.RightBrace);
            break;

        case 5:
            this.state = 431;
            this.match(CParser.T__0);
            this.state = 432;
            this.match(CParser.LeftParen);
            this.state = 433;
            this.typeName();
            this.state = 434;
            this.match(CParser.RightParen);
            this.state = 435;
            this.match(CParser.LeftBrace);
            this.state = 436;
            this.initializerList(0);
            this.state = 437;
            this.match(CParser.Comma);
            this.state = 438;
            this.match(CParser.RightBrace);
            break;

        }
        this._ctx.stop = this._input.LT(-1);
        this.state = 465;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,8,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 463;
                var la_ = this._interp.adaptivePredict(this._input,7,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new PostfixExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_postfixExpression);
                    this.state = 442;
                    if (!( this.precpred(this._ctx, 10))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 10)");
                    }
                    this.state = 443;
                    this.match(CParser.LeftBracket);
                    this.state = 444;
                    this.expression(0);
                    this.state = 445;
                    this.match(CParser.RightBracket);
                    break;

                case 2:
                    localctx = new PostfixExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_postfixExpression);
                    this.state = 447;
                    if (!( this.precpred(this._ctx, 9))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 9)");
                    }
                    this.state = 448;
                    this.match(CParser.LeftParen);
                    this.state = 450;
                    _la = this._input.LA(1);
                    if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                        this.state = 449;
                        this.argumentExpressionList(0);
                    }

                    this.state = 452;
                    this.match(CParser.RightParen);
                    break;

                case 3:
                    localctx = new PostfixExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_postfixExpression);
                    this.state = 453;
                    if (!( this.precpred(this._ctx, 8))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 8)");
                    }
                    this.state = 454;
                    this.match(CParser.Dot);
                    this.state = 455;
                    this.match(CParser.Identifier);
                    break;

                case 4:
                    localctx = new PostfixExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_postfixExpression);
                    this.state = 456;
                    if (!( this.precpred(this._ctx, 7))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 7)");
                    }
                    this.state = 457;
                    this.match(CParser.Arrow);
                    this.state = 458;
                    this.match(CParser.Identifier);
                    break;

                case 5:
                    localctx = new PostfixExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_postfixExpression);
                    this.state = 459;
                    if (!( this.precpred(this._ctx, 6))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)");
                    }
                    this.state = 460;
                    this.match(CParser.PlusPlus);
                    break;

                case 6:
                    localctx = new PostfixExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_postfixExpression);
                    this.state = 461;
                    if (!( this.precpred(this._ctx, 5))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)");
                    }
                    this.state = 462;
                    this.match(CParser.MinusMinus);
                    break;

                } 
            }
            this.state = 467;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,8,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ArgumentExpressionListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_argumentExpressionList;
    return this;
}

ArgumentExpressionListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ArgumentExpressionListContext.prototype.constructor = ArgumentExpressionListContext;

ArgumentExpressionListContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

ArgumentExpressionListContext.prototype.argumentExpressionList = function() {
    return this.getTypedRuleContext(ArgumentExpressionListContext,0);
};

ArgumentExpressionListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterArgumentExpressionList(this);
	}
};

ArgumentExpressionListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitArgumentExpressionList(this);
	}
};



CParser.prototype.argumentExpressionList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new ArgumentExpressionListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 10;
    this.enterRecursionRule(localctx, 10, CParser.RULE_argumentExpressionList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 469;
        this.assignmentExpression();
        this._ctx.stop = this._input.LT(-1);
        this.state = 476;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,9,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new ArgumentExpressionListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_argumentExpressionList);
                this.state = 471;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 472;
                this.match(CParser.Comma);
                this.state = 473;
                this.assignmentExpression(); 
            }
            this.state = 478;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,9,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function UnaryExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_unaryExpression;
    return this;
}

UnaryExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
UnaryExpressionContext.prototype.constructor = UnaryExpressionContext;

UnaryExpressionContext.prototype.postfixExpression = function() {
    return this.getTypedRuleContext(PostfixExpressionContext,0);
};

UnaryExpressionContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

UnaryExpressionContext.prototype.unaryOperator = function() {
    return this.getTypedRuleContext(UnaryOperatorContext,0);
};

UnaryExpressionContext.prototype.castExpression = function() {
    return this.getTypedRuleContext(CastExpressionContext,0);
};

UnaryExpressionContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

UnaryExpressionContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

UnaryExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterUnaryExpression(this);
	}
};

UnaryExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitUnaryExpression(this);
	}
};




CParser.UnaryExpressionContext = UnaryExpressionContext;

CParser.prototype.unaryExpression = function() {

    var localctx = new UnaryExpressionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 12, CParser.RULE_unaryExpression);
    try {
        this.state = 501;
        var la_ = this._interp.adaptivePredict(this._input,10,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 479;
            this.postfixExpression(0);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 480;
            this.match(CParser.PlusPlus);
            this.state = 481;
            this.unaryExpression();
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 482;
            this.match(CParser.MinusMinus);
            this.state = 483;
            this.unaryExpression();
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 484;
            this.unaryOperator();
            this.state = 485;
            this.castExpression();
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 487;
            this.match(CParser.Sizeof);
            this.state = 488;
            this.unaryExpression();
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 489;
            this.match(CParser.Sizeof);
            this.state = 490;
            this.match(CParser.LeftParen);
            this.state = 491;
            this.typeName();
            this.state = 492;
            this.match(CParser.RightParen);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 494;
            this.match(CParser.Alignof);
            this.state = 495;
            this.match(CParser.LeftParen);
            this.state = 496;
            this.typeName();
            this.state = 497;
            this.match(CParser.RightParen);
            break;

        case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 499;
            this.match(CParser.AndAnd);
            this.state = 500;
            this.match(CParser.Identifier);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function UnaryOperatorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_unaryOperator;
    return this;
}

UnaryOperatorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
UnaryOperatorContext.prototype.constructor = UnaryOperatorContext;


UnaryOperatorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterUnaryOperator(this);
	}
};

UnaryOperatorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitUnaryOperator(this);
	}
};




CParser.UnaryOperatorContext = UnaryOperatorContext;

CParser.prototype.unaryOperator = function() {

    var localctx = new UnaryOperatorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 14, CParser.RULE_unaryOperator);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 503;
        _la = this._input.LA(1);
        if(!(((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0))) {
        this._errHandler.recoverInline(this);
        }
        else {
            this.consume();
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function CastExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_castExpression;
    return this;
}

CastExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
CastExpressionContext.prototype.constructor = CastExpressionContext;

CastExpressionContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

CastExpressionContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

CastExpressionContext.prototype.castExpression = function() {
    return this.getTypedRuleContext(CastExpressionContext,0);
};

CastExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterCastExpression(this);
	}
};

CastExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitCastExpression(this);
	}
};




CParser.CastExpressionContext = CastExpressionContext;

CParser.prototype.castExpression = function() {

    var localctx = new CastExpressionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 16, CParser.RULE_castExpression);
    try {
        this.state = 517;
        var la_ = this._interp.adaptivePredict(this._input,11,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 505;
            this.unaryExpression();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 506;
            this.match(CParser.LeftParen);
            this.state = 507;
            this.typeName();
            this.state = 508;
            this.match(CParser.RightParen);
            this.state = 509;
            this.castExpression();
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 511;
            this.match(CParser.T__0);
            this.state = 512;
            this.match(CParser.LeftParen);
            this.state = 513;
            this.typeName();
            this.state = 514;
            this.match(CParser.RightParen);
            this.state = 515;
            this.castExpression();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function MultiplicativeExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_multiplicativeExpression;
    return this;
}

MultiplicativeExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
MultiplicativeExpressionContext.prototype.constructor = MultiplicativeExpressionContext;

MultiplicativeExpressionContext.prototype.castExpression = function() {
    return this.getTypedRuleContext(CastExpressionContext,0);
};

MultiplicativeExpressionContext.prototype.multiplicativeExpression = function() {
    return this.getTypedRuleContext(MultiplicativeExpressionContext,0);
};

MultiplicativeExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterMultiplicativeExpression(this);
	}
};

MultiplicativeExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitMultiplicativeExpression(this);
	}
};



CParser.prototype.multiplicativeExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new MultiplicativeExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 18;
    this.enterRecursionRule(localctx, 18, CParser.RULE_multiplicativeExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 520;
        this.castExpression();
        this._ctx.stop = this._input.LT(-1);
        this.state = 533;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,13,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 531;
                var la_ = this._interp.adaptivePredict(this._input,12,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new MultiplicativeExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_multiplicativeExpression);
                    this.state = 522;
                    if (!( this.precpred(this._ctx, 3))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 3)");
                    }
                    this.state = 523;
                    this.match(CParser.Star);
                    this.state = 524;
                    this.castExpression();
                    break;

                case 2:
                    localctx = new MultiplicativeExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_multiplicativeExpression);
                    this.state = 525;
                    if (!( this.precpred(this._ctx, 2))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
                    }
                    this.state = 526;
                    this.match(CParser.Div);
                    this.state = 527;
                    this.castExpression();
                    break;

                case 3:
                    localctx = new MultiplicativeExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_multiplicativeExpression);
                    this.state = 528;
                    if (!( this.precpred(this._ctx, 1))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                    }
                    this.state = 529;
                    this.match(CParser.Mod);
                    this.state = 530;
                    this.castExpression();
                    break;

                } 
            }
            this.state = 535;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,13,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function AdditiveExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_additiveExpression;
    return this;
}

AdditiveExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AdditiveExpressionContext.prototype.constructor = AdditiveExpressionContext;

AdditiveExpressionContext.prototype.multiplicativeExpression = function() {
    return this.getTypedRuleContext(MultiplicativeExpressionContext,0);
};

AdditiveExpressionContext.prototype.additiveExpression = function() {
    return this.getTypedRuleContext(AdditiveExpressionContext,0);
};

AdditiveExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAdditiveExpression(this);
	}
};

AdditiveExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAdditiveExpression(this);
	}
};



CParser.prototype.additiveExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new AdditiveExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 20;
    this.enterRecursionRule(localctx, 20, CParser.RULE_additiveExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 537;
        this.multiplicativeExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 547;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,15,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 545;
                var la_ = this._interp.adaptivePredict(this._input,14,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new AdditiveExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_additiveExpression);
                    this.state = 539;
                    if (!( this.precpred(this._ctx, 2))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
                    }
                    this.state = 540;
                    this.match(CParser.Plus);
                    this.state = 541;
                    this.multiplicativeExpression(0);
                    break;

                case 2:
                    localctx = new AdditiveExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_additiveExpression);
                    this.state = 542;
                    if (!( this.precpred(this._ctx, 1))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                    }
                    this.state = 543;
                    this.match(CParser.Minus);
                    this.state = 544;
                    this.multiplicativeExpression(0);
                    break;

                } 
            }
            this.state = 549;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,15,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ShiftExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_shiftExpression;
    return this;
}

ShiftExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ShiftExpressionContext.prototype.constructor = ShiftExpressionContext;

ShiftExpressionContext.prototype.additiveExpression = function() {
    return this.getTypedRuleContext(AdditiveExpressionContext,0);
};

ShiftExpressionContext.prototype.shiftExpression = function() {
    return this.getTypedRuleContext(ShiftExpressionContext,0);
};

ShiftExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterShiftExpression(this);
	}
};

ShiftExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitShiftExpression(this);
	}
};



CParser.prototype.shiftExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new ShiftExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 22;
    this.enterRecursionRule(localctx, 22, CParser.RULE_shiftExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 551;
        this.additiveExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 561;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,17,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 559;
                var la_ = this._interp.adaptivePredict(this._input,16,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new ShiftExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_shiftExpression);
                    this.state = 553;
                    if (!( this.precpred(this._ctx, 2))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
                    }
                    this.state = 554;
                    this.match(CParser.LeftShift);
                    this.state = 555;
                    this.additiveExpression(0);
                    break;

                case 2:
                    localctx = new ShiftExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_shiftExpression);
                    this.state = 556;
                    if (!( this.precpred(this._ctx, 1))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                    }
                    this.state = 557;
                    this.match(CParser.RightShift);
                    this.state = 558;
                    this.additiveExpression(0);
                    break;

                } 
            }
            this.state = 563;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,17,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function RelationalExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_relationalExpression;
    return this;
}

RelationalExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
RelationalExpressionContext.prototype.constructor = RelationalExpressionContext;

RelationalExpressionContext.prototype.shiftExpression = function() {
    return this.getTypedRuleContext(ShiftExpressionContext,0);
};

RelationalExpressionContext.prototype.relationalExpression = function() {
    return this.getTypedRuleContext(RelationalExpressionContext,0);
};

RelationalExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterRelationalExpression(this);
	}
};

RelationalExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitRelationalExpression(this);
	}
};



CParser.prototype.relationalExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new RelationalExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 24;
    this.enterRecursionRule(localctx, 24, CParser.RULE_relationalExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 565;
        this.shiftExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 581;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,19,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 579;
                var la_ = this._interp.adaptivePredict(this._input,18,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new RelationalExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_relationalExpression);
                    this.state = 567;
                    if (!( this.precpred(this._ctx, 4))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 4)");
                    }
                    this.state = 568;
                    this.match(CParser.Less);
                    this.state = 569;
                    this.shiftExpression(0);
                    break;

                case 2:
                    localctx = new RelationalExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_relationalExpression);
                    this.state = 570;
                    if (!( this.precpred(this._ctx, 3))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 3)");
                    }
                    this.state = 571;
                    this.match(CParser.Greater);
                    this.state = 572;
                    this.shiftExpression(0);
                    break;

                case 3:
                    localctx = new RelationalExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_relationalExpression);
                    this.state = 573;
                    if (!( this.precpred(this._ctx, 2))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
                    }
                    this.state = 574;
                    this.match(CParser.LessEqual);
                    this.state = 575;
                    this.shiftExpression(0);
                    break;

                case 4:
                    localctx = new RelationalExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_relationalExpression);
                    this.state = 576;
                    if (!( this.precpred(this._ctx, 1))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                    }
                    this.state = 577;
                    this.match(CParser.GreaterEqual);
                    this.state = 578;
                    this.shiftExpression(0);
                    break;

                } 
            }
            this.state = 583;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,19,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function EqualityExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_equalityExpression;
    return this;
}

EqualityExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EqualityExpressionContext.prototype.constructor = EqualityExpressionContext;

EqualityExpressionContext.prototype.relationalExpression = function() {
    return this.getTypedRuleContext(RelationalExpressionContext,0);
};

EqualityExpressionContext.prototype.equalityExpression = function() {
    return this.getTypedRuleContext(EqualityExpressionContext,0);
};

EqualityExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEqualityExpression(this);
	}
};

EqualityExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEqualityExpression(this);
	}
};



CParser.prototype.equalityExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new EqualityExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 26;
    this.enterRecursionRule(localctx, 26, CParser.RULE_equalityExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 585;
        this.relationalExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 595;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,21,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 593;
                var la_ = this._interp.adaptivePredict(this._input,20,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new EqualityExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_equalityExpression);
                    this.state = 587;
                    if (!( this.precpred(this._ctx, 2))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
                    }
                    this.state = 588;
                    this.match(CParser.Equal);
                    this.state = 589;
                    this.relationalExpression(0);
                    break;

                case 2:
                    localctx = new EqualityExpressionContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_equalityExpression);
                    this.state = 590;
                    if (!( this.precpred(this._ctx, 1))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                    }
                    this.state = 591;
                    this.match(CParser.NotEqual);
                    this.state = 592;
                    this.relationalExpression(0);
                    break;

                } 
            }
            this.state = 597;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,21,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function AndExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_andExpression;
    return this;
}

AndExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AndExpressionContext.prototype.constructor = AndExpressionContext;

AndExpressionContext.prototype.equalityExpression = function() {
    return this.getTypedRuleContext(EqualityExpressionContext,0);
};

AndExpressionContext.prototype.andExpression = function() {
    return this.getTypedRuleContext(AndExpressionContext,0);
};

AndExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAndExpression(this);
	}
};

AndExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAndExpression(this);
	}
};



CParser.prototype.andExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new AndExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 28;
    this.enterRecursionRule(localctx, 28, CParser.RULE_andExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 599;
        this.equalityExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 606;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,22,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new AndExpressionContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_andExpression);
                this.state = 601;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 602;
                this.match(CParser.And);
                this.state = 603;
                this.equalityExpression(0); 
            }
            this.state = 608;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,22,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ExclusiveOrExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_exclusiveOrExpression;
    return this;
}

ExclusiveOrExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ExclusiveOrExpressionContext.prototype.constructor = ExclusiveOrExpressionContext;

ExclusiveOrExpressionContext.prototype.andExpression = function() {
    return this.getTypedRuleContext(AndExpressionContext,0);
};

ExclusiveOrExpressionContext.prototype.exclusiveOrExpression = function() {
    return this.getTypedRuleContext(ExclusiveOrExpressionContext,0);
};

ExclusiveOrExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExclusiveOrExpression(this);
	}
};

ExclusiveOrExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExclusiveOrExpression(this);
	}
};



CParser.prototype.exclusiveOrExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new ExclusiveOrExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 30;
    this.enterRecursionRule(localctx, 30, CParser.RULE_exclusiveOrExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 610;
        this.andExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 617;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,23,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new ExclusiveOrExpressionContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_exclusiveOrExpression);
                this.state = 612;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 613;
                this.match(CParser.Caret);
                this.state = 614;
                this.andExpression(0); 
            }
            this.state = 619;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,23,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function InclusiveOrExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_inclusiveOrExpression;
    return this;
}

InclusiveOrExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InclusiveOrExpressionContext.prototype.constructor = InclusiveOrExpressionContext;

InclusiveOrExpressionContext.prototype.exclusiveOrExpression = function() {
    return this.getTypedRuleContext(ExclusiveOrExpressionContext,0);
};

InclusiveOrExpressionContext.prototype.inclusiveOrExpression = function() {
    return this.getTypedRuleContext(InclusiveOrExpressionContext,0);
};

InclusiveOrExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInclusiveOrExpression(this);
	}
};

InclusiveOrExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInclusiveOrExpression(this);
	}
};



CParser.prototype.inclusiveOrExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new InclusiveOrExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 32;
    this.enterRecursionRule(localctx, 32, CParser.RULE_inclusiveOrExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 621;
        this.exclusiveOrExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 628;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,24,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new InclusiveOrExpressionContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_inclusiveOrExpression);
                this.state = 623;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 624;
                this.match(CParser.Or);
                this.state = 625;
                this.exclusiveOrExpression(0); 
            }
            this.state = 630;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,24,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function LogicalAndExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_logicalAndExpression;
    return this;
}

LogicalAndExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
LogicalAndExpressionContext.prototype.constructor = LogicalAndExpressionContext;

LogicalAndExpressionContext.prototype.inclusiveOrExpression = function() {
    return this.getTypedRuleContext(InclusiveOrExpressionContext,0);
};

LogicalAndExpressionContext.prototype.logicalAndExpression = function() {
    return this.getTypedRuleContext(LogicalAndExpressionContext,0);
};

LogicalAndExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterLogicalAndExpression(this);
	}
};

LogicalAndExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitLogicalAndExpression(this);
	}
};



CParser.prototype.logicalAndExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new LogicalAndExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 34;
    this.enterRecursionRule(localctx, 34, CParser.RULE_logicalAndExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 632;
        this.inclusiveOrExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 639;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,25,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new LogicalAndExpressionContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_logicalAndExpression);
                this.state = 634;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 635;
                this.match(CParser.AndAnd);
                this.state = 636;
                this.inclusiveOrExpression(0); 
            }
            this.state = 641;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,25,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function LogicalOrExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_logicalOrExpression;
    return this;
}

LogicalOrExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
LogicalOrExpressionContext.prototype.constructor = LogicalOrExpressionContext;

LogicalOrExpressionContext.prototype.logicalAndExpression = function() {
    return this.getTypedRuleContext(LogicalAndExpressionContext,0);
};

LogicalOrExpressionContext.prototype.logicalOrExpression = function() {
    return this.getTypedRuleContext(LogicalOrExpressionContext,0);
};

LogicalOrExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterLogicalOrExpression(this);
	}
};

LogicalOrExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitLogicalOrExpression(this);
	}
};



CParser.prototype.logicalOrExpression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new LogicalOrExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 36;
    this.enterRecursionRule(localctx, 36, CParser.RULE_logicalOrExpression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 643;
        this.logicalAndExpression(0);
        this._ctx.stop = this._input.LT(-1);
        this.state = 650;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,26,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new LogicalOrExpressionContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_logicalOrExpression);
                this.state = 645;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 646;
                this.match(CParser.OrOr);
                this.state = 647;
                this.logicalAndExpression(0); 
            }
            this.state = 652;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,26,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ConditionalExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_conditionalExpression;
    return this;
}

ConditionalExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ConditionalExpressionContext.prototype.constructor = ConditionalExpressionContext;

ConditionalExpressionContext.prototype.logicalOrExpression = function() {
    return this.getTypedRuleContext(LogicalOrExpressionContext,0);
};

ConditionalExpressionContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

ConditionalExpressionContext.prototype.conditionalExpression = function() {
    return this.getTypedRuleContext(ConditionalExpressionContext,0);
};

ConditionalExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterConditionalExpression(this);
	}
};

ConditionalExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitConditionalExpression(this);
	}
};




CParser.ConditionalExpressionContext = ConditionalExpressionContext;

CParser.prototype.conditionalExpression = function() {

    var localctx = new ConditionalExpressionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 38, CParser.RULE_conditionalExpression);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 653;
        this.logicalOrExpression(0);
        this.state = 659;
        var la_ = this._interp.adaptivePredict(this._input,27,this._ctx);
        if(la_===1) {
            this.state = 654;
            this.match(CParser.Question);
            this.state = 655;
            this.expression(0);
            this.state = 656;
            this.match(CParser.Colon);
            this.state = 657;
            this.conditionalExpression();

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AssignmentExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_assignmentExpression;
    return this;
}

AssignmentExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AssignmentExpressionContext.prototype.constructor = AssignmentExpressionContext;

AssignmentExpressionContext.prototype.conditionalExpression = function() {
    return this.getTypedRuleContext(ConditionalExpressionContext,0);
};

AssignmentExpressionContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

AssignmentExpressionContext.prototype.assignmentOperator = function() {
    return this.getTypedRuleContext(AssignmentOperatorContext,0);
};

AssignmentExpressionContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

AssignmentExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAssignmentExpression(this);
	}
};

AssignmentExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAssignmentExpression(this);
	}
};




CParser.AssignmentExpressionContext = AssignmentExpressionContext;

CParser.prototype.assignmentExpression = function() {

    var localctx = new AssignmentExpressionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 40, CParser.RULE_assignmentExpression);
    try {
        this.state = 666;
        var la_ = this._interp.adaptivePredict(this._input,28,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 661;
            this.conditionalExpression();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 662;
            this.unaryExpression();
            this.state = 663;
            this.assignmentOperator();
            this.state = 664;
            this.assignmentExpression();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AssignmentOperatorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_assignmentOperator;
    return this;
}

AssignmentOperatorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AssignmentOperatorContext.prototype.constructor = AssignmentOperatorContext;


AssignmentOperatorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAssignmentOperator(this);
	}
};

AssignmentOperatorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAssignmentOperator(this);
	}
};




CParser.AssignmentOperatorContext = AssignmentOperatorContext;

CParser.prototype.assignmentOperator = function() {

    var localctx = new AssignmentOperatorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 42, CParser.RULE_assignmentOperator);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 668;
        _la = this._input.LA(1);
        if(!(((((_la - 89)) & ~0x1f) == 0 && ((1 << (_la - 89)) & ((1 << (CParser.Assign - 89)) | (1 << (CParser.StarAssign - 89)) | (1 << (CParser.DivAssign - 89)) | (1 << (CParser.ModAssign - 89)) | (1 << (CParser.PlusAssign - 89)) | (1 << (CParser.MinusAssign - 89)) | (1 << (CParser.LeftShiftAssign - 89)) | (1 << (CParser.RightShiftAssign - 89)) | (1 << (CParser.AndAssign - 89)) | (1 << (CParser.XorAssign - 89)) | (1 << (CParser.OrAssign - 89)))) !== 0))) {
        this._errHandler.recoverInline(this);
        }
        else {
            this.consume();
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_expression;
    return this;
}

ExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ExpressionContext.prototype.constructor = ExpressionContext;

ExpressionContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

ExpressionContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

ExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExpression(this);
	}
};

ExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExpression(this);
	}
};



CParser.prototype.expression = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new ExpressionContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 44;
    this.enterRecursionRule(localctx, 44, CParser.RULE_expression, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 671;
        this.assignmentExpression();
        this._ctx.stop = this._input.LT(-1);
        this.state = 678;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,29,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new ExpressionContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_expression);
                this.state = 673;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 674;
                this.match(CParser.Comma);
                this.state = 675;
                this.assignmentExpression(); 
            }
            this.state = 680;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,29,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ConstantExpressionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_constantExpression;
    return this;
}

ConstantExpressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ConstantExpressionContext.prototype.constructor = ConstantExpressionContext;

ConstantExpressionContext.prototype.conditionalExpression = function() {
    return this.getTypedRuleContext(ConditionalExpressionContext,0);
};

ConstantExpressionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterConstantExpression(this);
	}
};

ConstantExpressionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitConstantExpression(this);
	}
};




CParser.ConstantExpressionContext = ConstantExpressionContext;

CParser.prototype.constantExpression = function() {

    var localctx = new ConstantExpressionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 46, CParser.RULE_constantExpression);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 681;
        this.conditionalExpression();
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declaration;
    return this;
}

DeclarationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationContext.prototype.constructor = DeclarationContext;

DeclarationContext.prototype.declarationSpecifiers = function() {
    return this.getTypedRuleContext(DeclarationSpecifiersContext,0);
};

DeclarationContext.prototype.initDeclaratorList = function() {
    return this.getTypedRuleContext(InitDeclaratorListContext,0);
};

DeclarationContext.prototype.staticAssertDeclaration = function() {
    return this.getTypedRuleContext(StaticAssertDeclarationContext,0);
};

DeclarationContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclaration(this);
	}
};

DeclarationContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclaration(this);
	}
};




CParser.DeclarationContext = DeclarationContext;

CParser.prototype.declaration = function() {

    var localctx = new DeclarationContext(this, this._ctx, this.state);
    this.enterRule(localctx, 48, CParser.RULE_declaration);
    var _la = 0; // Token type
    try {
        this.state = 690;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.T__7:
        case CParser.T__8:
        case CParser.T__9:
        case CParser.T__11:
        case CParser.Auto:
        case CParser.Char:
        case CParser.Const:
        case CParser.Double:
        case CParser.Enum:
        case CParser.Extern:
        case CParser.Float:
        case CParser.Inline:
        case CParser.Int:
        case CParser.Long:
        case CParser.Register:
        case CParser.Restrict:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Static:
        case CParser.Struct:
        case CParser.Typedef:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.Alignas:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Noreturn:
        case CParser.ThreadLocal:
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 683;
            this.declarationSpecifiers();
            this.state = 685;
            _la = this._input.LA(1);
            if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) !== 0) || _la===CParser.Identifier) {
                this.state = 684;
                this.initDeclaratorList(0);
            }

            this.state = 687;
            this.match(CParser.Semi);
            break;
        case CParser.StaticAssert:
            this.enterOuterAlt(localctx, 2);
            this.state = 689;
            this.staticAssertDeclaration();
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationSpecifiersContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationSpecifiers;
    return this;
}

DeclarationSpecifiersContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationSpecifiersContext.prototype.constructor = DeclarationSpecifiersContext;

DeclarationSpecifiersContext.prototype.declarationSpecifier = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(DeclarationSpecifierContext);
    } else {
        return this.getTypedRuleContext(DeclarationSpecifierContext,i);
    }
};

DeclarationSpecifiersContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationSpecifiers(this);
	}
};

DeclarationSpecifiersContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationSpecifiers(this);
	}
};




CParser.DeclarationSpecifiersContext = DeclarationSpecifiersContext;

CParser.prototype.declarationSpecifiers = function() {

    var localctx = new DeclarationSpecifiersContext(this, this._ctx, this.state);
    this.enterRule(localctx, 50, CParser.RULE_declarationSpecifiers);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 693; 
        this._errHandler.sync(this);
        var _alt = 1;
        do {
        	switch (_alt) {
        	case 1:
        		this.state = 692;
        		this.declarationSpecifier();
        		break;
        	default:
        		throw new antlr4.error.NoViableAltException(this);
        	}
        	this.state = 695; 
        	this._errHandler.sync(this);
        	_alt = this._interp.adaptivePredict(this._input,32, this._ctx);
        } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER );
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationSpecifiers2Context(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationSpecifiers2;
    return this;
}

DeclarationSpecifiers2Context.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationSpecifiers2Context.prototype.constructor = DeclarationSpecifiers2Context;

DeclarationSpecifiers2Context.prototype.declarationSpecifier = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(DeclarationSpecifierContext);
    } else {
        return this.getTypedRuleContext(DeclarationSpecifierContext,i);
    }
};

DeclarationSpecifiers2Context.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationSpecifiers2(this);
	}
};

DeclarationSpecifiers2Context.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationSpecifiers2(this);
	}
};




CParser.DeclarationSpecifiers2Context = DeclarationSpecifiers2Context;

CParser.prototype.declarationSpecifiers2 = function() {

    var localctx = new DeclarationSpecifiers2Context(this, this._ctx, this.state);
    this.enterRule(localctx, 52, CParser.RULE_declarationSpecifiers2);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 698; 
        this._errHandler.sync(this);
        var _alt = 1;
        do {
        	switch (_alt) {
        	case 1:
        		this.state = 697;
        		this.declarationSpecifier();
        		break;
        	default:
        		throw new antlr4.error.NoViableAltException(this);
        	}
        	this.state = 700; 
        	this._errHandler.sync(this);
        	_alt = this._interp.adaptivePredict(this._input,33, this._ctx);
        } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER );
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationSpecifier;
    return this;
}

DeclarationSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationSpecifierContext.prototype.constructor = DeclarationSpecifierContext;

DeclarationSpecifierContext.prototype.storageClassSpecifier = function() {
    return this.getTypedRuleContext(StorageClassSpecifierContext,0);
};

DeclarationSpecifierContext.prototype.typeSpecifier = function() {
    return this.getTypedRuleContext(TypeSpecifierContext,0);
};

DeclarationSpecifierContext.prototype.typeQualifier = function() {
    return this.getTypedRuleContext(TypeQualifierContext,0);
};

DeclarationSpecifierContext.prototype.functionSpecifier = function() {
    return this.getTypedRuleContext(FunctionSpecifierContext,0);
};

DeclarationSpecifierContext.prototype.alignmentSpecifier = function() {
    return this.getTypedRuleContext(AlignmentSpecifierContext,0);
};

DeclarationSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationSpecifier(this);
	}
};

DeclarationSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationSpecifier(this);
	}
};




CParser.DeclarationSpecifierContext = DeclarationSpecifierContext;

CParser.prototype.declarationSpecifier = function() {

    var localctx = new DeclarationSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 54, CParser.RULE_declarationSpecifier);
    try {
        this.state = 707;
        var la_ = this._interp.adaptivePredict(this._input,34,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 702;
            this.storageClassSpecifier();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 703;
            this.typeSpecifier();
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 704;
            this.typeQualifier();
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 705;
            this.functionSpecifier();
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 706;
            this.alignmentSpecifier();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function InitDeclaratorListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initDeclaratorList;
    return this;
}

InitDeclaratorListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InitDeclaratorListContext.prototype.constructor = InitDeclaratorListContext;

InitDeclaratorListContext.prototype.initDeclarator = function() {
    return this.getTypedRuleContext(InitDeclaratorContext,0);
};

InitDeclaratorListContext.prototype.initDeclaratorList = function() {
    return this.getTypedRuleContext(InitDeclaratorListContext,0);
};

InitDeclaratorListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitDeclaratorList(this);
	}
};

InitDeclaratorListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitDeclaratorList(this);
	}
};



CParser.prototype.initDeclaratorList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new InitDeclaratorListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 56;
    this.enterRecursionRule(localctx, 56, CParser.RULE_initDeclaratorList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 710;
        this.initDeclarator();
        this._ctx.stop = this._input.LT(-1);
        this.state = 717;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,35,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new InitDeclaratorListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_initDeclaratorList);
                this.state = 712;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 713;
                this.match(CParser.Comma);
                this.state = 714;
                this.initDeclarator(); 
            }
            this.state = 719;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,35,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function InitDeclaratorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initDeclarator;
    return this;
}

InitDeclaratorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InitDeclaratorContext.prototype.constructor = InitDeclaratorContext;

InitDeclaratorContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

InitDeclaratorContext.prototype.initializer = function() {
    return this.getTypedRuleContext(InitializerContext,0);
};

InitDeclaratorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitDeclarator(this);
	}
};

InitDeclaratorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitDeclarator(this);
	}
};




CParser.InitDeclaratorContext = InitDeclaratorContext;

CParser.prototype.initDeclarator = function() {

    var localctx = new InitDeclaratorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 58, CParser.RULE_initDeclarator);
    try {
        this.state = 725;
        var la_ = this._interp.adaptivePredict(this._input,36,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 720;
            this.declarator();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 721;
            this.declarator();
            this.state = 722;
            this.match(CParser.Assign);
            this.state = 723;
            this.initializer();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StorageClassSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_storageClassSpecifier;
    return this;
}

StorageClassSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StorageClassSpecifierContext.prototype.constructor = StorageClassSpecifierContext;


StorageClassSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStorageClassSpecifier(this);
	}
};

StorageClassSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStorageClassSpecifier(this);
	}
};




CParser.StorageClassSpecifierContext = StorageClassSpecifierContext;

CParser.prototype.storageClassSpecifier = function() {

    var localctx = new StorageClassSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 60, CParser.RULE_storageClassSpecifier);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 727;
        _la = this._input.LA(1);
        if(!(_la===CParser.Auto || _la===CParser.Extern || ((((_la - 34)) & ~0x1f) == 0 && ((1 << (_la - 34)) & ((1 << (CParser.Register - 34)) | (1 << (CParser.Static - 34)) | (1 << (CParser.Typedef - 34)) | (1 << (CParser.ThreadLocal - 34)))) !== 0))) {
        this._errHandler.recoverInline(this);
        }
        else {
            this.consume();
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypeSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeSpecifier;
    return this;
}

TypeSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeSpecifierContext.prototype.constructor = TypeSpecifierContext;

TypeSpecifierContext.prototype.atomicTypeSpecifier = function() {
    return this.getTypedRuleContext(AtomicTypeSpecifierContext,0);
};

TypeSpecifierContext.prototype.structOrUnionSpecifier = function() {
    return this.getTypedRuleContext(StructOrUnionSpecifierContext,0);
};

TypeSpecifierContext.prototype.enumSpecifier = function() {
    return this.getTypedRuleContext(EnumSpecifierContext,0);
};

TypeSpecifierContext.prototype.typedefName = function() {
    return this.getTypedRuleContext(TypedefNameContext,0);
};

TypeSpecifierContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

TypeSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeSpecifier(this);
	}
};

TypeSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeSpecifier(this);
	}
};




CParser.TypeSpecifierContext = TypeSpecifierContext;

CParser.prototype.typeSpecifier = function() {

    var localctx = new TypeSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 62, CParser.RULE_typeSpecifier);
    var _la = 0; // Token type
    try {
        this.state = 743;
        switch(this._input.LA(1)) {
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.Char:
        case CParser.Double:
        case CParser.Float:
        case CParser.Int:
        case CParser.Long:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Bool:
        case CParser.Complex:
            this.enterOuterAlt(localctx, 1);
            this.state = 729;
            _la = this._input.LA(1);
            if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.Char) | (1 << CParser.Double) | (1 << CParser.Float))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)))) !== 0))) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            break;
        case CParser.T__0:
            this.enterOuterAlt(localctx, 2);
            this.state = 730;
            this.match(CParser.T__0);
            this.state = 731;
            this.match(CParser.LeftParen);
            this.state = 732;
            _la = this._input.LA(1);
            if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5))) !== 0))) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 733;
            this.match(CParser.RightParen);
            break;
        case CParser.Atomic:
            this.enterOuterAlt(localctx, 3);
            this.state = 734;
            this.atomicTypeSpecifier();
            break;
        case CParser.Struct:
        case CParser.Union:
            this.enterOuterAlt(localctx, 4);
            this.state = 735;
            this.structOrUnionSpecifier();
            break;
        case CParser.Enum:
            this.enterOuterAlt(localctx, 5);
            this.state = 736;
            this.enumSpecifier();
            break;
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 6);
            this.state = 737;
            this.typedefName();
            break;
        case CParser.T__6:
            this.enterOuterAlt(localctx, 7);
            this.state = 738;
            this.match(CParser.T__6);
            this.state = 739;
            this.match(CParser.LeftParen);
            this.state = 740;
            this.constantExpression();
            this.state = 741;
            this.match(CParser.RightParen);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructOrUnionSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structOrUnionSpecifier;
    return this;
}

StructOrUnionSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructOrUnionSpecifierContext.prototype.constructor = StructOrUnionSpecifierContext;

StructOrUnionSpecifierContext.prototype.structOrUnion = function() {
    return this.getTypedRuleContext(StructOrUnionContext,0);
};

StructOrUnionSpecifierContext.prototype.structDeclarationsBlock = function() {
    return this.getTypedRuleContext(StructDeclarationsBlockContext,0);
};

StructOrUnionSpecifierContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

StructOrUnionSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructOrUnionSpecifier(this);
	}
};

StructOrUnionSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructOrUnionSpecifier(this);
	}
};




CParser.StructOrUnionSpecifierContext = StructOrUnionSpecifierContext;

CParser.prototype.structOrUnionSpecifier = function() {

    var localctx = new StructOrUnionSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 64, CParser.RULE_structOrUnionSpecifier);
    var _la = 0; // Token type
    try {
        this.state = 754;
        var la_ = this._interp.adaptivePredict(this._input,39,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 745;
            this.structOrUnion();
            this.state = 747;
            _la = this._input.LA(1);
            if(_la===CParser.Identifier) {
                this.state = 746;
                this.match(CParser.Identifier);
            }

            this.state = 749;
            this.structDeclarationsBlock();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 751;
            this.structOrUnion();
            this.state = 752;
            this.match(CParser.Identifier);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructOrUnionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structOrUnion;
    return this;
}

StructOrUnionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructOrUnionContext.prototype.constructor = StructOrUnionContext;


StructOrUnionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructOrUnion(this);
	}
};

StructOrUnionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructOrUnion(this);
	}
};




CParser.StructOrUnionContext = StructOrUnionContext;

CParser.prototype.structOrUnion = function() {

    var localctx = new StructOrUnionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 66, CParser.RULE_structOrUnion);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 756;
        _la = this._input.LA(1);
        if(!(_la===CParser.Struct || _la===CParser.Union)) {
        this._errHandler.recoverInline(this);
        }
        else {
            this.consume();
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclarationsBlockContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclarationsBlock;
    return this;
}

StructDeclarationsBlockContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclarationsBlockContext.prototype.constructor = StructDeclarationsBlockContext;

StructDeclarationsBlockContext.prototype.structDeclarationList = function() {
    return this.getTypedRuleContext(StructDeclarationListContext,0);
};

StructDeclarationsBlockContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclarationsBlock(this);
	}
};

StructDeclarationsBlockContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclarationsBlock(this);
	}
};




CParser.StructDeclarationsBlockContext = StructDeclarationsBlockContext;

CParser.prototype.structDeclarationsBlock = function() {

    var localctx = new StructDeclarationsBlockContext(this, this._ctx, this.state);
    this.enterRule(localctx, 68, CParser.RULE_structDeclarationsBlock);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 758;
        this.match(CParser.LeftBrace);
        this.state = 759;
        this.structDeclarationList(0);
        this.state = 760;
        this.match(CParser.RightBrace);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclarationListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclarationList;
    return this;
}

StructDeclarationListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclarationListContext.prototype.constructor = StructDeclarationListContext;

StructDeclarationListContext.prototype.structDeclaration = function() {
    return this.getTypedRuleContext(StructDeclarationContext,0);
};

StructDeclarationListContext.prototype.structDeclarationList = function() {
    return this.getTypedRuleContext(StructDeclarationListContext,0);
};

StructDeclarationListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclarationList(this);
	}
};

StructDeclarationListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclarationList(this);
	}
};



CParser.prototype.structDeclarationList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new StructDeclarationListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 70;
    this.enterRecursionRule(localctx, 70, CParser.RULE_structDeclarationList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 763;
        this.structDeclaration();
        this._ctx.stop = this._input.LT(-1);
        this.state = 769;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,40,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new StructDeclarationListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_structDeclarationList);
                this.state = 765;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 766;
                this.structDeclaration(); 
            }
            this.state = 771;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,40,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function StructDeclarationContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclaration;
    return this;
}

StructDeclarationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclarationContext.prototype.constructor = StructDeclarationContext;

StructDeclarationContext.prototype.specifierQualifierList = function() {
    return this.getTypedRuleContext(SpecifierQualifierListContext,0);
};

StructDeclarationContext.prototype.structDeclaratorList = function() {
    return this.getTypedRuleContext(StructDeclaratorListContext,0);
};

StructDeclarationContext.prototype.staticAssertDeclaration = function() {
    return this.getTypedRuleContext(StaticAssertDeclarationContext,0);
};

StructDeclarationContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclaration(this);
	}
};

StructDeclarationContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclaration(this);
	}
};




CParser.StructDeclarationContext = StructDeclarationContext;

CParser.prototype.structDeclaration = function() {

    var localctx = new StructDeclarationContext(this, this._ctx, this.state);
    this.enterRule(localctx, 72, CParser.RULE_structDeclaration);
    var _la = 0; // Token type
    try {
        this.state = 779;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.Char:
        case CParser.Const:
        case CParser.Double:
        case CParser.Enum:
        case CParser.Float:
        case CParser.Int:
        case CParser.Long:
        case CParser.Restrict:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Struct:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 772;
            this.specifierQualifierList();
            this.state = 774;
            _la = this._input.LA(1);
            if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Colon - 59)))) !== 0) || _la===CParser.Identifier) {
                this.state = 773;
                this.structDeclaratorList(0);
            }

            this.state = 776;
            this.match(CParser.Semi);
            break;
        case CParser.StaticAssert:
            this.enterOuterAlt(localctx, 2);
            this.state = 778;
            this.staticAssertDeclaration();
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function SpecifierQualifierListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_specifierQualifierList;
    return this;
}

SpecifierQualifierListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
SpecifierQualifierListContext.prototype.constructor = SpecifierQualifierListContext;

SpecifierQualifierListContext.prototype.typeSpecifier = function() {
    return this.getTypedRuleContext(TypeSpecifierContext,0);
};

SpecifierQualifierListContext.prototype.specifierQualifierList = function() {
    return this.getTypedRuleContext(SpecifierQualifierListContext,0);
};

SpecifierQualifierListContext.prototype.typeQualifier = function() {
    return this.getTypedRuleContext(TypeQualifierContext,0);
};

SpecifierQualifierListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterSpecifierQualifierList(this);
	}
};

SpecifierQualifierListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitSpecifierQualifierList(this);
	}
};




CParser.SpecifierQualifierListContext = SpecifierQualifierListContext;

CParser.prototype.specifierQualifierList = function() {

    var localctx = new SpecifierQualifierListContext(this, this._ctx, this.state);
    this.enterRule(localctx, 74, CParser.RULE_specifierQualifierList);
    try {
        this.state = 789;
        var la_ = this._interp.adaptivePredict(this._input,45,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 781;
            this.typeSpecifier();
            this.state = 783;
            var la_ = this._interp.adaptivePredict(this._input,43,this._ctx);
            if(la_===1) {
                this.state = 782;
                this.specifierQualifierList();

            }
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 785;
            this.typeQualifier();
            this.state = 787;
            var la_ = this._interp.adaptivePredict(this._input,44,this._ctx);
            if(la_===1) {
                this.state = 786;
                this.specifierQualifierList();

            }
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclaratorListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclaratorList;
    return this;
}

StructDeclaratorListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclaratorListContext.prototype.constructor = StructDeclaratorListContext;

StructDeclaratorListContext.prototype.structDeclarator = function() {
    return this.getTypedRuleContext(StructDeclaratorContext,0);
};

StructDeclaratorListContext.prototype.structDeclaratorList = function() {
    return this.getTypedRuleContext(StructDeclaratorListContext,0);
};

StructDeclaratorListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclaratorList(this);
	}
};

StructDeclaratorListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclaratorList(this);
	}
};



CParser.prototype.structDeclaratorList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new StructDeclaratorListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 76;
    this.enterRecursionRule(localctx, 76, CParser.RULE_structDeclaratorList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 792;
        this.structDeclarator();
        this._ctx.stop = this._input.LT(-1);
        this.state = 799;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,46,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new StructDeclaratorListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_structDeclaratorList);
                this.state = 794;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 795;
                this.match(CParser.Comma);
                this.state = 796;
                this.structDeclarator(); 
            }
            this.state = 801;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,46,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function StructDeclaratorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclarator;
    return this;
}

StructDeclaratorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclaratorContext.prototype.constructor = StructDeclaratorContext;

StructDeclaratorContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

StructDeclaratorContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

StructDeclaratorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclarator(this);
	}
};

StructDeclaratorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclarator(this);
	}
};




CParser.StructDeclaratorContext = StructDeclaratorContext;

CParser.prototype.structDeclarator = function() {

    var localctx = new StructDeclaratorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 78, CParser.RULE_structDeclarator);
    var _la = 0; // Token type
    try {
        this.state = 808;
        var la_ = this._interp.adaptivePredict(this._input,48,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 802;
            this.declarator();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 804;
            _la = this._input.LA(1);
            if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) !== 0) || _la===CParser.Identifier) {
                this.state = 803;
                this.declarator();
            }

            this.state = 806;
            this.match(CParser.Colon);
            this.state = 807;
            this.constantExpression();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function EnumSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumSpecifier;
    return this;
}

EnumSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EnumSpecifierContext.prototype.constructor = EnumSpecifierContext;

EnumSpecifierContext.prototype.enumeratorList = function() {
    return this.getTypedRuleContext(EnumeratorListContext,0);
};

EnumSpecifierContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

EnumSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumSpecifier(this);
	}
};

EnumSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumSpecifier(this);
	}
};




CParser.EnumSpecifierContext = EnumSpecifierContext;

CParser.prototype.enumSpecifier = function() {

    var localctx = new EnumSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 80, CParser.RULE_enumSpecifier);
    var _la = 0; // Token type
    try {
        this.state = 829;
        var la_ = this._interp.adaptivePredict(this._input,51,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 810;
            this.match(CParser.Enum);
            this.state = 812;
            _la = this._input.LA(1);
            if(_la===CParser.Identifier) {
                this.state = 811;
                this.match(CParser.Identifier);
            }

            this.state = 814;
            this.match(CParser.LeftBrace);
            this.state = 815;
            this.enumeratorList(0);
            this.state = 816;
            this.match(CParser.RightBrace);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 818;
            this.match(CParser.Enum);
            this.state = 820;
            _la = this._input.LA(1);
            if(_la===CParser.Identifier) {
                this.state = 819;
                this.match(CParser.Identifier);
            }

            this.state = 822;
            this.match(CParser.LeftBrace);
            this.state = 823;
            this.enumeratorList(0);
            this.state = 824;
            this.match(CParser.Comma);
            this.state = 825;
            this.match(CParser.RightBrace);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 827;
            this.match(CParser.Enum);
            this.state = 828;
            this.match(CParser.Identifier);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function EnumeratorListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumeratorList;
    return this;
}

EnumeratorListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EnumeratorListContext.prototype.constructor = EnumeratorListContext;

EnumeratorListContext.prototype.enumerator = function() {
    return this.getTypedRuleContext(EnumeratorContext,0);
};

EnumeratorListContext.prototype.enumeratorList = function() {
    return this.getTypedRuleContext(EnumeratorListContext,0);
};

EnumeratorListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumeratorList(this);
	}
};

EnumeratorListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumeratorList(this);
	}
};



CParser.prototype.enumeratorList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new EnumeratorListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 82;
    this.enterRecursionRule(localctx, 82, CParser.RULE_enumeratorList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 832;
        this.enumerator();
        this._ctx.stop = this._input.LT(-1);
        this.state = 839;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,52,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new EnumeratorListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_enumeratorList);
                this.state = 834;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 835;
                this.match(CParser.Comma);
                this.state = 836;
                this.enumerator(); 
            }
            this.state = 841;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,52,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function EnumeratorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumerator;
    return this;
}

EnumeratorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EnumeratorContext.prototype.constructor = EnumeratorContext;

EnumeratorContext.prototype.enumerationConstant = function() {
    return this.getTypedRuleContext(EnumerationConstantContext,0);
};

EnumeratorContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

EnumeratorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumerator(this);
	}
};

EnumeratorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumerator(this);
	}
};




CParser.EnumeratorContext = EnumeratorContext;

CParser.prototype.enumerator = function() {

    var localctx = new EnumeratorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 84, CParser.RULE_enumerator);
    try {
        this.state = 847;
        var la_ = this._interp.adaptivePredict(this._input,53,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 842;
            this.enumerationConstant();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 843;
            this.enumerationConstant();
            this.state = 844;
            this.match(CParser.Assign);
            this.state = 845;
            this.constantExpression();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function EnumerationConstantContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumerationConstant;
    return this;
}

EnumerationConstantContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EnumerationConstantContext.prototype.constructor = EnumerationConstantContext;

EnumerationConstantContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

EnumerationConstantContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumerationConstant(this);
	}
};

EnumerationConstantContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumerationConstant(this);
	}
};




CParser.EnumerationConstantContext = EnumerationConstantContext;

CParser.prototype.enumerationConstant = function() {

    var localctx = new EnumerationConstantContext(this, this._ctx, this.state);
    this.enterRule(localctx, 86, CParser.RULE_enumerationConstant);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 849;
        this.match(CParser.Identifier);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AtomicTypeSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_atomicTypeSpecifier;
    return this;
}

AtomicTypeSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AtomicTypeSpecifierContext.prototype.constructor = AtomicTypeSpecifierContext;

AtomicTypeSpecifierContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

AtomicTypeSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAtomicTypeSpecifier(this);
	}
};

AtomicTypeSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAtomicTypeSpecifier(this);
	}
};




CParser.AtomicTypeSpecifierContext = AtomicTypeSpecifierContext;

CParser.prototype.atomicTypeSpecifier = function() {

    var localctx = new AtomicTypeSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 88, CParser.RULE_atomicTypeSpecifier);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 851;
        this.match(CParser.Atomic);
        this.state = 852;
        this.match(CParser.LeftParen);
        this.state = 853;
        this.typeName();
        this.state = 854;
        this.match(CParser.RightParen);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypeQualifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeQualifier;
    return this;
}

TypeQualifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeQualifierContext.prototype.constructor = TypeQualifierContext;


TypeQualifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeQualifier(this);
	}
};

TypeQualifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeQualifier(this);
	}
};




CParser.TypeQualifierContext = TypeQualifierContext;

CParser.prototype.typeQualifier = function() {

    var localctx = new TypeQualifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 90, CParser.RULE_typeQualifier);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 856;
        _la = this._input.LA(1);
        if(!(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0))) {
        this._errHandler.recoverInline(this);
        }
        else {
            this.consume();
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function FunctionSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_functionSpecifier;
    return this;
}

FunctionSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
FunctionSpecifierContext.prototype.constructor = FunctionSpecifierContext;

FunctionSpecifierContext.prototype.gccAttributeSpecifier = function() {
    return this.getTypedRuleContext(GccAttributeSpecifierContext,0);
};

FunctionSpecifierContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

FunctionSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterFunctionSpecifier(this);
	}
};

FunctionSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitFunctionSpecifier(this);
	}
};




CParser.FunctionSpecifierContext = FunctionSpecifierContext;

CParser.prototype.functionSpecifier = function() {

    var localctx = new FunctionSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 92, CParser.RULE_functionSpecifier);
    var _la = 0; // Token type
    try {
        this.state = 864;
        switch(this._input.LA(1)) {
        case CParser.T__7:
        case CParser.T__8:
        case CParser.Inline:
        case CParser.Noreturn:
            this.enterOuterAlt(localctx, 1);
            this.state = 858;
            _la = this._input.LA(1);
            if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.Inline))) !== 0) || _la===CParser.Noreturn)) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            break;
        case CParser.T__11:
            this.enterOuterAlt(localctx, 2);
            this.state = 859;
            this.gccAttributeSpecifier();
            break;
        case CParser.T__9:
            this.enterOuterAlt(localctx, 3);
            this.state = 860;
            this.match(CParser.T__9);
            this.state = 861;
            this.match(CParser.LeftParen);
            this.state = 862;
            this.match(CParser.Identifier);
            this.state = 863;
            this.match(CParser.RightParen);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AlignmentSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_alignmentSpecifier;
    return this;
}

AlignmentSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AlignmentSpecifierContext.prototype.constructor = AlignmentSpecifierContext;

AlignmentSpecifierContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

AlignmentSpecifierContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

AlignmentSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAlignmentSpecifier(this);
	}
};

AlignmentSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAlignmentSpecifier(this);
	}
};




CParser.AlignmentSpecifierContext = AlignmentSpecifierContext;

CParser.prototype.alignmentSpecifier = function() {

    var localctx = new AlignmentSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 94, CParser.RULE_alignmentSpecifier);
    try {
        this.state = 876;
        var la_ = this._interp.adaptivePredict(this._input,55,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 866;
            this.match(CParser.Alignas);
            this.state = 867;
            this.match(CParser.LeftParen);
            this.state = 868;
            this.typeName();
            this.state = 869;
            this.match(CParser.RightParen);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 871;
            this.match(CParser.Alignas);
            this.state = 872;
            this.match(CParser.LeftParen);
            this.state = 873;
            this.constantExpression();
            this.state = 874;
            this.match(CParser.RightParen);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclaratorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarator;
    return this;
}

DeclaratorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclaratorContext.prototype.constructor = DeclaratorContext;

DeclaratorContext.prototype.directDeclarator = function() {
    return this.getTypedRuleContext(DirectDeclaratorContext,0);
};

DeclaratorContext.prototype.pointer = function() {
    return this.getTypedRuleContext(PointerContext,0);
};

DeclaratorContext.prototype.gccDeclaratorExtension = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccDeclaratorExtensionContext);
    } else {
        return this.getTypedRuleContext(GccDeclaratorExtensionContext,i);
    }
};

DeclaratorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarator(this);
	}
};

DeclaratorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarator(this);
	}
};




CParser.DeclaratorContext = DeclaratorContext;

CParser.prototype.declarator = function() {

    var localctx = new DeclaratorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 96, CParser.RULE_declarator);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 879;
        _la = this._input.LA(1);
        if(_la===CParser.Star || _la===CParser.Caret) {
            this.state = 878;
            this.pointer();
        }

        this.state = 881;
        this.directDeclarator(0);
        this.state = 885;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,57,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                this.state = 882;
                this.gccDeclaratorExtension(); 
            }
            this.state = 887;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,57,this._ctx);
        }

    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DirectDeclaratorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_directDeclarator;
    return this;
}

DirectDeclaratorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DirectDeclaratorContext.prototype.constructor = DirectDeclaratorContext;

DirectDeclaratorContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

DirectDeclaratorContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

DirectDeclaratorContext.prototype.directDeclarator = function() {
    return this.getTypedRuleContext(DirectDeclaratorContext,0);
};

DirectDeclaratorContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

DirectDeclaratorContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

DirectDeclaratorContext.prototype.parameterTypeList = function() {
    return this.getTypedRuleContext(ParameterTypeListContext,0);
};

DirectDeclaratorContext.prototype.identifierList = function() {
    return this.getTypedRuleContext(IdentifierListContext,0);
};

DirectDeclaratorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDirectDeclarator(this);
	}
};

DirectDeclaratorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDirectDeclarator(this);
	}
};



CParser.prototype.directDeclarator = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new DirectDeclaratorContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 98;
    this.enterRecursionRule(localctx, 98, CParser.RULE_directDeclarator, _p);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 894;
        switch(this._input.LA(1)) {
        case CParser.Identifier:
            this.state = 889;
            this.match(CParser.Identifier);
            break;
        case CParser.LeftParen:
            this.state = 890;
            this.match(CParser.LeftParen);
            this.state = 891;
            this.declarator();
            this.state = 892;
            this.match(CParser.RightParen);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
        this._ctx.stop = this._input.LT(-1);
        this.state = 941;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,65,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 939;
                var la_ = this._interp.adaptivePredict(this._input,64,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new DirectDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directDeclarator);
                    this.state = 896;
                    if (!( this.precpred(this._ctx, 6))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)");
                    }
                    this.state = 897;
                    this.match(CParser.LeftBracket);
                    this.state = 899;
                    _la = this._input.LA(1);
                    if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                        this.state = 898;
                        this.typeQualifierList(0);
                    }

                    this.state = 902;
                    _la = this._input.LA(1);
                    if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                        this.state = 901;
                        this.assignmentExpression();
                    }

                    this.state = 904;
                    this.match(CParser.RightBracket);
                    break;

                case 2:
                    localctx = new DirectDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directDeclarator);
                    this.state = 905;
                    if (!( this.precpred(this._ctx, 5))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)");
                    }
                    this.state = 906;
                    this.match(CParser.LeftBracket);
                    this.state = 907;
                    this.match(CParser.Static);
                    this.state = 909;
                    _la = this._input.LA(1);
                    if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                        this.state = 908;
                        this.typeQualifierList(0);
                    }

                    this.state = 911;
                    this.assignmentExpression();
                    this.state = 912;
                    this.match(CParser.RightBracket);
                    break;

                case 3:
                    localctx = new DirectDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directDeclarator);
                    this.state = 914;
                    if (!( this.precpred(this._ctx, 4))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 4)");
                    }
                    this.state = 915;
                    this.match(CParser.LeftBracket);
                    this.state = 916;
                    this.typeQualifierList(0);
                    this.state = 917;
                    this.match(CParser.Static);
                    this.state = 918;
                    this.assignmentExpression();
                    this.state = 919;
                    this.match(CParser.RightBracket);
                    break;

                case 4:
                    localctx = new DirectDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directDeclarator);
                    this.state = 921;
                    if (!( this.precpred(this._ctx, 3))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 3)");
                    }
                    this.state = 922;
                    this.match(CParser.LeftBracket);
                    this.state = 924;
                    _la = this._input.LA(1);
                    if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                        this.state = 923;
                        this.typeQualifierList(0);
                    }

                    this.state = 926;
                    this.match(CParser.Star);
                    this.state = 927;
                    this.match(CParser.RightBracket);
                    break;

                case 5:
                    localctx = new DirectDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directDeclarator);
                    this.state = 928;
                    if (!( this.precpred(this._ctx, 2))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
                    }
                    this.state = 929;
                    this.match(CParser.LeftParen);
                    this.state = 930;
                    this.parameterTypeList();
                    this.state = 931;
                    this.match(CParser.RightParen);
                    break;

                case 6:
                    localctx = new DirectDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directDeclarator);
                    this.state = 933;
                    if (!( this.precpred(this._ctx, 1))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                    }
                    this.state = 934;
                    this.match(CParser.LeftParen);
                    this.state = 936;
                    _la = this._input.LA(1);
                    if(_la===CParser.Identifier) {
                        this.state = 935;
                        this.identifierList(0);
                    }

                    this.state = 938;
                    this.match(CParser.RightParen);
                    break;

                } 
            }
            this.state = 943;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,65,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function GccDeclaratorExtensionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccDeclaratorExtension;
    return this;
}

GccDeclaratorExtensionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccDeclaratorExtensionContext.prototype.constructor = GccDeclaratorExtensionContext;

GccDeclaratorExtensionContext.prototype.StringLiteral = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.StringLiteral);
    } else {
        return this.getToken(CParser.StringLiteral, i);
    }
};


GccDeclaratorExtensionContext.prototype.gccAttributeSpecifier = function() {
    return this.getTypedRuleContext(GccAttributeSpecifierContext,0);
};

GccDeclaratorExtensionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccDeclaratorExtension(this);
	}
};

GccDeclaratorExtensionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccDeclaratorExtension(this);
	}
};




CParser.GccDeclaratorExtensionContext = GccDeclaratorExtensionContext;

CParser.prototype.gccDeclaratorExtension = function() {

    var localctx = new GccDeclaratorExtensionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 100, CParser.RULE_gccDeclaratorExtension);
    var _la = 0; // Token type
    try {
        this.state = 953;
        switch(this._input.LA(1)) {
        case CParser.T__10:
            this.enterOuterAlt(localctx, 1);
            this.state = 944;
            this.match(CParser.T__10);
            this.state = 945;
            this.match(CParser.LeftParen);
            this.state = 947; 
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            do {
                this.state = 946;
                this.match(CParser.StringLiteral);
                this.state = 949; 
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            } while(_la===CParser.StringLiteral);
            this.state = 951;
            this.match(CParser.RightParen);
            break;
        case CParser.T__11:
            this.enterOuterAlt(localctx, 2);
            this.state = 952;
            this.gccAttributeSpecifier();
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GccAttributeSpecifierContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccAttributeSpecifier;
    return this;
}

GccAttributeSpecifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccAttributeSpecifierContext.prototype.constructor = GccAttributeSpecifierContext;

GccAttributeSpecifierContext.prototype.gccAttributeList = function() {
    return this.getTypedRuleContext(GccAttributeListContext,0);
};

GccAttributeSpecifierContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccAttributeSpecifier(this);
	}
};

GccAttributeSpecifierContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccAttributeSpecifier(this);
	}
};




CParser.GccAttributeSpecifierContext = GccAttributeSpecifierContext;

CParser.prototype.gccAttributeSpecifier = function() {

    var localctx = new GccAttributeSpecifierContext(this, this._ctx, this.state);
    this.enterRule(localctx, 102, CParser.RULE_gccAttributeSpecifier);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 955;
        this.match(CParser.T__11);
        this.state = 956;
        this.match(CParser.LeftParen);
        this.state = 957;
        this.match(CParser.LeftParen);
        this.state = 958;
        this.gccAttributeList();
        this.state = 959;
        this.match(CParser.RightParen);
        this.state = 960;
        this.match(CParser.RightParen);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GccAttributeListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccAttributeList;
    return this;
}

GccAttributeListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccAttributeListContext.prototype.constructor = GccAttributeListContext;

GccAttributeListContext.prototype.gccAttribute = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccAttributeContext);
    } else {
        return this.getTypedRuleContext(GccAttributeContext,i);
    }
};

GccAttributeListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccAttributeList(this);
	}
};

GccAttributeListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccAttributeList(this);
	}
};




CParser.GccAttributeListContext = GccAttributeListContext;

CParser.prototype.gccAttributeList = function() {

    var localctx = new GccAttributeListContext(this, this._ctx, this.state);
    this.enterRule(localctx, 104, CParser.RULE_gccAttributeList);
    var _la = 0; // Token type
    try {
        this.state = 971;
        var la_ = this._interp.adaptivePredict(this._input,69,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 962;
            this.gccAttribute();
            this.state = 967;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.Comma) {
                this.state = 963;
                this.match(CParser.Comma);
                this.state = 964;
                this.gccAttribute();
                this.state = 969;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);

            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GccAttributeContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccAttribute;
    return this;
}

GccAttributeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccAttributeContext.prototype.constructor = GccAttributeContext;

GccAttributeContext.prototype.argumentExpressionList = function() {
    return this.getTypedRuleContext(ArgumentExpressionListContext,0);
};

GccAttributeContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccAttribute(this);
	}
};

GccAttributeContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccAttribute(this);
	}
};




CParser.GccAttributeContext = GccAttributeContext;

CParser.prototype.gccAttribute = function() {

    var localctx = new GccAttributeContext(this, this._ctx, this.state);
    this.enterRule(localctx, 106, CParser.RULE_gccAttribute);
    var _la = 0; // Token type
    try {
        this.state = 982;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__1:
        case CParser.T__2:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.T__7:
        case CParser.T__8:
        case CParser.T__9:
        case CParser.T__10:
        case CParser.T__11:
        case CParser.T__12:
        case CParser.T__13:
        case CParser.Auto:
        case CParser.Break:
        case CParser.Case:
        case CParser.Char:
        case CParser.Const:
        case CParser.Continue:
        case CParser.Default:
        case CParser.Do:
        case CParser.Double:
        case CParser.Else:
        case CParser.Enum:
        case CParser.Extern:
        case CParser.Float:
        case CParser.For:
        case CParser.Goto:
        case CParser.If:
        case CParser.Inline:
        case CParser.Int:
        case CParser.Long:
        case CParser.Register:
        case CParser.Restrict:
        case CParser.Return:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Sizeof:
        case CParser.Static:
        case CParser.Struct:
        case CParser.Switch:
        case CParser.Typedef:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.While:
        case CParser.Alignas:
        case CParser.Alignof:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Generic:
        case CParser.Imaginary:
        case CParser.Noreturn:
        case CParser.StaticAssert:
        case CParser.ThreadLocal:
        case CParser.LeftBracket:
        case CParser.RightBracket:
        case CParser.LeftBrace:
        case CParser.RightBrace:
        case CParser.Less:
        case CParser.LessEqual:
        case CParser.Greater:
        case CParser.GreaterEqual:
        case CParser.LeftShift:
        case CParser.RightShift:
        case CParser.Plus:
        case CParser.PlusPlus:
        case CParser.Minus:
        case CParser.MinusMinus:
        case CParser.Star:
        case CParser.Div:
        case CParser.Mod:
        case CParser.And:
        case CParser.Or:
        case CParser.AndAnd:
        case CParser.OrOr:
        case CParser.Caret:
        case CParser.Not:
        case CParser.Tilde:
        case CParser.Question:
        case CParser.Colon:
        case CParser.Semi:
        case CParser.Assign:
        case CParser.StarAssign:
        case CParser.DivAssign:
        case CParser.ModAssign:
        case CParser.PlusAssign:
        case CParser.MinusAssign:
        case CParser.LeftShiftAssign:
        case CParser.RightShiftAssign:
        case CParser.AndAssign:
        case CParser.XorAssign:
        case CParser.OrAssign:
        case CParser.Equal:
        case CParser.NotEqual:
        case CParser.Arrow:
        case CParser.Dot:
        case CParser.Ellipsis:
        case CParser.Identifier:
        case CParser.Constant:
        case CParser.StringLiteral:
        case CParser.Directive:
        case CParser.Whitespace:
        case CParser.Newline:
        case CParser.BlockComment:
        case CParser.LineComment:
            this.enterOuterAlt(localctx, 1);
            this.state = 973;
            _la = this._input.LA(1);
            if(_la<=0 || ((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.RightParen - 59)) | (1 << (CParser.Comma - 59)))) !== 0)) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 979;
            _la = this._input.LA(1);
            if(_la===CParser.LeftParen) {
                this.state = 974;
                this.match(CParser.LeftParen);
                this.state = 976;
                _la = this._input.LA(1);
                if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                    this.state = 975;
                    this.argumentExpressionList(0);
                }

                this.state = 978;
                this.match(CParser.RightParen);
            }

            break;
        case CParser.EOF:
        case CParser.RightParen:
        case CParser.Comma:
            this.enterOuterAlt(localctx, 2);

            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function NestedParenthesesBlockContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_nestedParenthesesBlock;
    return this;
}

NestedParenthesesBlockContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
NestedParenthesesBlockContext.prototype.constructor = NestedParenthesesBlockContext;

NestedParenthesesBlockContext.prototype.nestedParenthesesBlock = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(NestedParenthesesBlockContext);
    } else {
        return this.getTypedRuleContext(NestedParenthesesBlockContext,i);
    }
};

NestedParenthesesBlockContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterNestedParenthesesBlock(this);
	}
};

NestedParenthesesBlockContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitNestedParenthesesBlock(this);
	}
};




CParser.NestedParenthesesBlockContext = NestedParenthesesBlockContext;

CParser.prototype.nestedParenthesesBlock = function() {

    var localctx = new NestedParenthesesBlockContext(this, this._ctx, this.state);
    this.enterRule(localctx, 108, CParser.RULE_nestedParenthesesBlock);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 991;
        this._errHandler.sync(this);
        _la = this._input.LA(1);
        while((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Else) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Return - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Sizeof - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Switch - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.While - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Alignof - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Generic - 32)) | (1 << (CParser.Imaginary - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)) | (1 << (CParser.LeftParen - 32)) | (1 << (CParser.LeftBracket - 32)) | (1 << (CParser.RightBracket - 32)) | (1 << (CParser.LeftBrace - 32)))) !== 0) || ((((_la - 64)) & ~0x1f) == 0 && ((1 << (_la - 64)) & ((1 << (CParser.RightBrace - 64)) | (1 << (CParser.Less - 64)) | (1 << (CParser.LessEqual - 64)) | (1 << (CParser.Greater - 64)) | (1 << (CParser.GreaterEqual - 64)) | (1 << (CParser.LeftShift - 64)) | (1 << (CParser.RightShift - 64)) | (1 << (CParser.Plus - 64)) | (1 << (CParser.PlusPlus - 64)) | (1 << (CParser.Minus - 64)) | (1 << (CParser.MinusMinus - 64)) | (1 << (CParser.Star - 64)) | (1 << (CParser.Div - 64)) | (1 << (CParser.Mod - 64)) | (1 << (CParser.And - 64)) | (1 << (CParser.Or - 64)) | (1 << (CParser.AndAnd - 64)) | (1 << (CParser.OrOr - 64)) | (1 << (CParser.Caret - 64)) | (1 << (CParser.Not - 64)) | (1 << (CParser.Tilde - 64)) | (1 << (CParser.Question - 64)) | (1 << (CParser.Colon - 64)) | (1 << (CParser.Semi - 64)) | (1 << (CParser.Comma - 64)) | (1 << (CParser.Assign - 64)) | (1 << (CParser.StarAssign - 64)) | (1 << (CParser.DivAssign - 64)) | (1 << (CParser.ModAssign - 64)) | (1 << (CParser.PlusAssign - 64)) | (1 << (CParser.MinusAssign - 64)) | (1 << (CParser.LeftShiftAssign - 64)))) !== 0) || ((((_la - 96)) & ~0x1f) == 0 && ((1 << (_la - 96)) & ((1 << (CParser.RightShiftAssign - 96)) | (1 << (CParser.AndAssign - 96)) | (1 << (CParser.XorAssign - 96)) | (1 << (CParser.OrAssign - 96)) | (1 << (CParser.Equal - 96)) | (1 << (CParser.NotEqual - 96)) | (1 << (CParser.Arrow - 96)) | (1 << (CParser.Dot - 96)) | (1 << (CParser.Ellipsis - 96)) | (1 << (CParser.Identifier - 96)) | (1 << (CParser.Constant - 96)) | (1 << (CParser.StringLiteral - 96)) | (1 << (CParser.Directive - 96)) | (1 << (CParser.Whitespace - 96)) | (1 << (CParser.Newline - 96)) | (1 << (CParser.BlockComment - 96)) | (1 << (CParser.LineComment - 96)))) !== 0)) {
            this.state = 989;
            switch(this._input.LA(1)) {
            case CParser.T__0:
            case CParser.T__1:
            case CParser.T__2:
            case CParser.T__3:
            case CParser.T__4:
            case CParser.T__5:
            case CParser.T__6:
            case CParser.T__7:
            case CParser.T__8:
            case CParser.T__9:
            case CParser.T__10:
            case CParser.T__11:
            case CParser.T__12:
            case CParser.T__13:
            case CParser.Auto:
            case CParser.Break:
            case CParser.Case:
            case CParser.Char:
            case CParser.Const:
            case CParser.Continue:
            case CParser.Default:
            case CParser.Do:
            case CParser.Double:
            case CParser.Else:
            case CParser.Enum:
            case CParser.Extern:
            case CParser.Float:
            case CParser.For:
            case CParser.Goto:
            case CParser.If:
            case CParser.Inline:
            case CParser.Int:
            case CParser.Long:
            case CParser.Register:
            case CParser.Restrict:
            case CParser.Return:
            case CParser.Short:
            case CParser.Signed:
            case CParser.Sizeof:
            case CParser.Static:
            case CParser.Struct:
            case CParser.Switch:
            case CParser.Typedef:
            case CParser.Union:
            case CParser.Unsigned:
            case CParser.Void:
            case CParser.Volatile:
            case CParser.While:
            case CParser.Alignas:
            case CParser.Alignof:
            case CParser.Atomic:
            case CParser.Bool:
            case CParser.Complex:
            case CParser.Generic:
            case CParser.Imaginary:
            case CParser.Noreturn:
            case CParser.StaticAssert:
            case CParser.ThreadLocal:
            case CParser.LeftBracket:
            case CParser.RightBracket:
            case CParser.LeftBrace:
            case CParser.RightBrace:
            case CParser.Less:
            case CParser.LessEqual:
            case CParser.Greater:
            case CParser.GreaterEqual:
            case CParser.LeftShift:
            case CParser.RightShift:
            case CParser.Plus:
            case CParser.PlusPlus:
            case CParser.Minus:
            case CParser.MinusMinus:
            case CParser.Star:
            case CParser.Div:
            case CParser.Mod:
            case CParser.And:
            case CParser.Or:
            case CParser.AndAnd:
            case CParser.OrOr:
            case CParser.Caret:
            case CParser.Not:
            case CParser.Tilde:
            case CParser.Question:
            case CParser.Colon:
            case CParser.Semi:
            case CParser.Comma:
            case CParser.Assign:
            case CParser.StarAssign:
            case CParser.DivAssign:
            case CParser.ModAssign:
            case CParser.PlusAssign:
            case CParser.MinusAssign:
            case CParser.LeftShiftAssign:
            case CParser.RightShiftAssign:
            case CParser.AndAssign:
            case CParser.XorAssign:
            case CParser.OrAssign:
            case CParser.Equal:
            case CParser.NotEqual:
            case CParser.Arrow:
            case CParser.Dot:
            case CParser.Ellipsis:
            case CParser.Identifier:
            case CParser.Constant:
            case CParser.StringLiteral:
            case CParser.Directive:
            case CParser.Whitespace:
            case CParser.Newline:
            case CParser.BlockComment:
            case CParser.LineComment:
                this.state = 984;
                _la = this._input.LA(1);
                if(_la<=0 || _la===CParser.LeftParen || _la===CParser.RightParen) {
                this._errHandler.recoverInline(this);
                }
                else {
                    this.consume();
                }
                break;
            case CParser.LeftParen:
                this.state = 985;
                this.match(CParser.LeftParen);
                this.state = 986;
                this.nestedParenthesesBlock();
                this.state = 987;
                this.match(CParser.RightParen);
                break;
            default:
                throw new antlr4.error.NoViableAltException(this);
            }
            this.state = 993;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function PointerContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_pointer;
    return this;
}

PointerContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
PointerContext.prototype.constructor = PointerContext;

PointerContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

PointerContext.prototype.pointer = function() {
    return this.getTypedRuleContext(PointerContext,0);
};

PointerContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterPointer(this);
	}
};

PointerContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitPointer(this);
	}
};




CParser.PointerContext = PointerContext;

CParser.prototype.pointer = function() {

    var localctx = new PointerContext(this, this._ctx, this.state);
    this.enterRule(localctx, 110, CParser.RULE_pointer);
    var _la = 0; // Token type
    try {
        this.state = 1012;
        var la_ = this._interp.adaptivePredict(this._input,79,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 994;
            this.match(CParser.Star);
            this.state = 996;
            var la_ = this._interp.adaptivePredict(this._input,75,this._ctx);
            if(la_===1) {
                this.state = 995;
                this.typeQualifierList(0);

            }
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 998;
            this.match(CParser.Star);
            this.state = 1000;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 999;
                this.typeQualifierList(0);
            }

            this.state = 1002;
            this.pointer();
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1003;
            this.match(CParser.Caret);
            this.state = 1005;
            var la_ = this._interp.adaptivePredict(this._input,77,this._ctx);
            if(la_===1) {
                this.state = 1004;
                this.typeQualifierList(0);

            }
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1007;
            this.match(CParser.Caret);
            this.state = 1009;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 1008;
                this.typeQualifierList(0);
            }

            this.state = 1011;
            this.pointer();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypeQualifierListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeQualifierList;
    return this;
}

TypeQualifierListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeQualifierListContext.prototype.constructor = TypeQualifierListContext;

TypeQualifierListContext.prototype.typeQualifier = function() {
    return this.getTypedRuleContext(TypeQualifierContext,0);
};

TypeQualifierListContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

TypeQualifierListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeQualifierList(this);
	}
};

TypeQualifierListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeQualifierList(this);
	}
};



CParser.prototype.typeQualifierList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new TypeQualifierListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 112;
    this.enterRecursionRule(localctx, 112, CParser.RULE_typeQualifierList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1015;
        this.typeQualifier();
        this._ctx.stop = this._input.LT(-1);
        this.state = 1021;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,80,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new TypeQualifierListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_typeQualifierList);
                this.state = 1017;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1018;
                this.typeQualifier(); 
            }
            this.state = 1023;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,80,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ParameterTypeListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_parameterTypeList;
    return this;
}

ParameterTypeListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ParameterTypeListContext.prototype.constructor = ParameterTypeListContext;

ParameterTypeListContext.prototype.parameterList = function() {
    return this.getTypedRuleContext(ParameterListContext,0);
};

ParameterTypeListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterParameterTypeList(this);
	}
};

ParameterTypeListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitParameterTypeList(this);
	}
};




CParser.ParameterTypeListContext = ParameterTypeListContext;

CParser.prototype.parameterTypeList = function() {

    var localctx = new ParameterTypeListContext(this, this._ctx, this.state);
    this.enterRule(localctx, 114, CParser.RULE_parameterTypeList);
    try {
        this.state = 1029;
        var la_ = this._interp.adaptivePredict(this._input,81,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1024;
            this.parameterList(0);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1025;
            this.parameterList(0);
            this.state = 1026;
            this.match(CParser.Comma);
            this.state = 1027;
            this.match(CParser.Ellipsis);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ParameterListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_parameterList;
    return this;
}

ParameterListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ParameterListContext.prototype.constructor = ParameterListContext;

ParameterListContext.prototype.parameterDeclaration = function() {
    return this.getTypedRuleContext(ParameterDeclarationContext,0);
};

ParameterListContext.prototype.parameterList = function() {
    return this.getTypedRuleContext(ParameterListContext,0);
};

ParameterListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterParameterList(this);
	}
};

ParameterListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitParameterList(this);
	}
};



CParser.prototype.parameterList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new ParameterListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 116;
    this.enterRecursionRule(localctx, 116, CParser.RULE_parameterList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1032;
        this.parameterDeclaration();
        this._ctx.stop = this._input.LT(-1);
        this.state = 1039;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,82,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new ParameterListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_parameterList);
                this.state = 1034;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1035;
                this.match(CParser.Comma);
                this.state = 1036;
                this.parameterDeclaration(); 
            }
            this.state = 1041;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,82,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ParameterDeclarationContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_parameterDeclaration;
    return this;
}

ParameterDeclarationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ParameterDeclarationContext.prototype.constructor = ParameterDeclarationContext;

ParameterDeclarationContext.prototype.declarationSpecifiers = function() {
    return this.getTypedRuleContext(DeclarationSpecifiersContext,0);
};

ParameterDeclarationContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

ParameterDeclarationContext.prototype.declarationSpecifiers2 = function() {
    return this.getTypedRuleContext(DeclarationSpecifiers2Context,0);
};

ParameterDeclarationContext.prototype.abstractDeclarator = function() {
    return this.getTypedRuleContext(AbstractDeclaratorContext,0);
};

ParameterDeclarationContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterParameterDeclaration(this);
	}
};

ParameterDeclarationContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitParameterDeclaration(this);
	}
};




CParser.ParameterDeclarationContext = ParameterDeclarationContext;

CParser.prototype.parameterDeclaration = function() {

    var localctx = new ParameterDeclarationContext(this, this._ctx, this.state);
    this.enterRule(localctx, 118, CParser.RULE_parameterDeclaration);
    try {
        this.state = 1049;
        var la_ = this._interp.adaptivePredict(this._input,84,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1042;
            this.declarationSpecifiers();
            this.state = 1043;
            this.declarator();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1045;
            this.declarationSpecifiers2();
            this.state = 1047;
            var la_ = this._interp.adaptivePredict(this._input,83,this._ctx);
            if(la_===1) {
                this.state = 1046;
                this.abstractDeclarator();

            }
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function IdentifierListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_identifierList;
    return this;
}

IdentifierListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
IdentifierListContext.prototype.constructor = IdentifierListContext;

IdentifierListContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

IdentifierListContext.prototype.identifierList = function() {
    return this.getTypedRuleContext(IdentifierListContext,0);
};

IdentifierListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterIdentifierList(this);
	}
};

IdentifierListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitIdentifierList(this);
	}
};



CParser.prototype.identifierList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new IdentifierListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 120;
    this.enterRecursionRule(localctx, 120, CParser.RULE_identifierList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1052;
        this.match(CParser.Identifier);
        this._ctx.stop = this._input.LT(-1);
        this.state = 1059;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,85,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new IdentifierListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_identifierList);
                this.state = 1054;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1055;
                this.match(CParser.Comma);
                this.state = 1056;
                this.match(CParser.Identifier); 
            }
            this.state = 1061;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,85,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function TypeNameContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeName;
    return this;
}

TypeNameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeNameContext.prototype.constructor = TypeNameContext;

TypeNameContext.prototype.specifierQualifierList = function() {
    return this.getTypedRuleContext(SpecifierQualifierListContext,0);
};

TypeNameContext.prototype.abstractDeclarator = function() {
    return this.getTypedRuleContext(AbstractDeclaratorContext,0);
};

TypeNameContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeName(this);
	}
};

TypeNameContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeName(this);
	}
};




CParser.TypeNameContext = TypeNameContext;

CParser.prototype.typeName = function() {

    var localctx = new TypeNameContext(this, this._ctx, this.state);
    this.enterRule(localctx, 122, CParser.RULE_typeName);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1062;
        this.specifierQualifierList();
        this.state = 1064;
        _la = this._input.LA(1);
        if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.LeftBracket - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) !== 0)) {
            this.state = 1063;
            this.abstractDeclarator();
        }

    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AbstractDeclaratorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_abstractDeclarator;
    return this;
}

AbstractDeclaratorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AbstractDeclaratorContext.prototype.constructor = AbstractDeclaratorContext;

AbstractDeclaratorContext.prototype.pointer = function() {
    return this.getTypedRuleContext(PointerContext,0);
};

AbstractDeclaratorContext.prototype.directAbstractDeclarator = function() {
    return this.getTypedRuleContext(DirectAbstractDeclaratorContext,0);
};

AbstractDeclaratorContext.prototype.gccDeclaratorExtension = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccDeclaratorExtensionContext);
    } else {
        return this.getTypedRuleContext(GccDeclaratorExtensionContext,i);
    }
};

AbstractDeclaratorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAbstractDeclarator(this);
	}
};

AbstractDeclaratorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAbstractDeclarator(this);
	}
};




CParser.AbstractDeclaratorContext = AbstractDeclaratorContext;

CParser.prototype.abstractDeclarator = function() {

    var localctx = new AbstractDeclaratorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 124, CParser.RULE_abstractDeclarator);
    var _la = 0; // Token type
    try {
        this.state = 1077;
        var la_ = this._interp.adaptivePredict(this._input,89,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1066;
            this.pointer();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1068;
            _la = this._input.LA(1);
            if(_la===CParser.Star || _la===CParser.Caret) {
                this.state = 1067;
                this.pointer();
            }

            this.state = 1070;
            this.directAbstractDeclarator(0);
            this.state = 1074;
            this._errHandler.sync(this);
            var _alt = this._interp.adaptivePredict(this._input,88,this._ctx)
            while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
                if(_alt===1) {
                    this.state = 1071;
                    this.gccDeclaratorExtension(); 
                }
                this.state = 1076;
                this._errHandler.sync(this);
                _alt = this._interp.adaptivePredict(this._input,88,this._ctx);
            }

            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DirectAbstractDeclaratorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_directAbstractDeclarator;
    return this;
}

DirectAbstractDeclaratorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DirectAbstractDeclaratorContext.prototype.constructor = DirectAbstractDeclaratorContext;

DirectAbstractDeclaratorContext.prototype.abstractDeclarator = function() {
    return this.getTypedRuleContext(AbstractDeclaratorContext,0);
};

DirectAbstractDeclaratorContext.prototype.gccDeclaratorExtension = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccDeclaratorExtensionContext);
    } else {
        return this.getTypedRuleContext(GccDeclaratorExtensionContext,i);
    }
};

DirectAbstractDeclaratorContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

DirectAbstractDeclaratorContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

DirectAbstractDeclaratorContext.prototype.parameterTypeList = function() {
    return this.getTypedRuleContext(ParameterTypeListContext,0);
};

DirectAbstractDeclaratorContext.prototype.directAbstractDeclarator = function() {
    return this.getTypedRuleContext(DirectAbstractDeclaratorContext,0);
};

DirectAbstractDeclaratorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDirectAbstractDeclarator(this);
	}
};

DirectAbstractDeclaratorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDirectAbstractDeclarator(this);
	}
};



CParser.prototype.directAbstractDeclarator = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new DirectAbstractDeclaratorContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 126;
    this.enterRecursionRule(localctx, 126, CParser.RULE_directAbstractDeclarator, _p);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1125;
        var la_ = this._interp.adaptivePredict(this._input,96,this._ctx);
        switch(la_) {
        case 1:
            this.state = 1080;
            this.match(CParser.LeftParen);
            this.state = 1081;
            this.abstractDeclarator();
            this.state = 1082;
            this.match(CParser.RightParen);
            this.state = 1086;
            this._errHandler.sync(this);
            var _alt = this._interp.adaptivePredict(this._input,90,this._ctx)
            while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
                if(_alt===1) {
                    this.state = 1083;
                    this.gccDeclaratorExtension(); 
                }
                this.state = 1088;
                this._errHandler.sync(this);
                _alt = this._interp.adaptivePredict(this._input,90,this._ctx);
            }

            break;

        case 2:
            this.state = 1089;
            this.match(CParser.LeftBracket);
            this.state = 1091;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 1090;
                this.typeQualifierList(0);
            }

            this.state = 1094;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1093;
                this.assignmentExpression();
            }

            this.state = 1096;
            this.match(CParser.RightBracket);
            break;

        case 3:
            this.state = 1097;
            this.match(CParser.LeftBracket);
            this.state = 1098;
            this.match(CParser.Static);
            this.state = 1100;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 1099;
                this.typeQualifierList(0);
            }

            this.state = 1102;
            this.assignmentExpression();
            this.state = 1103;
            this.match(CParser.RightBracket);
            break;

        case 4:
            this.state = 1105;
            this.match(CParser.LeftBracket);
            this.state = 1106;
            this.typeQualifierList(0);
            this.state = 1107;
            this.match(CParser.Static);
            this.state = 1108;
            this.assignmentExpression();
            this.state = 1109;
            this.match(CParser.RightBracket);
            break;

        case 5:
            this.state = 1111;
            this.match(CParser.LeftBracket);
            this.state = 1112;
            this.match(CParser.Star);
            this.state = 1113;
            this.match(CParser.RightBracket);
            break;

        case 6:
            this.state = 1114;
            this.match(CParser.LeftParen);
            this.state = 1116;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier) {
                this.state = 1115;
                this.parameterTypeList();
            }

            this.state = 1118;
            this.match(CParser.RightParen);
            this.state = 1122;
            this._errHandler.sync(this);
            var _alt = this._interp.adaptivePredict(this._input,95,this._ctx)
            while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
                if(_alt===1) {
                    this.state = 1119;
                    this.gccDeclaratorExtension(); 
                }
                this.state = 1124;
                this._errHandler.sync(this);
                _alt = this._interp.adaptivePredict(this._input,95,this._ctx);
            }

            break;

        }
        this._ctx.stop = this._input.LT(-1);
        this.state = 1170;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,103,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                this.state = 1168;
                var la_ = this._interp.adaptivePredict(this._input,102,this._ctx);
                switch(la_) {
                case 1:
                    localctx = new DirectAbstractDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directAbstractDeclarator);
                    this.state = 1127;
                    if (!( this.precpred(this._ctx, 5))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)");
                    }
                    this.state = 1128;
                    this.match(CParser.LeftBracket);
                    this.state = 1130;
                    _la = this._input.LA(1);
                    if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                        this.state = 1129;
                        this.typeQualifierList(0);
                    }

                    this.state = 1133;
                    _la = this._input.LA(1);
                    if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                        this.state = 1132;
                        this.assignmentExpression();
                    }

                    this.state = 1135;
                    this.match(CParser.RightBracket);
                    break;

                case 2:
                    localctx = new DirectAbstractDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directAbstractDeclarator);
                    this.state = 1136;
                    if (!( this.precpred(this._ctx, 4))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 4)");
                    }
                    this.state = 1137;
                    this.match(CParser.LeftBracket);
                    this.state = 1138;
                    this.match(CParser.Static);
                    this.state = 1140;
                    _la = this._input.LA(1);
                    if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                        this.state = 1139;
                        this.typeQualifierList(0);
                    }

                    this.state = 1142;
                    this.assignmentExpression();
                    this.state = 1143;
                    this.match(CParser.RightBracket);
                    break;

                case 3:
                    localctx = new DirectAbstractDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directAbstractDeclarator);
                    this.state = 1145;
                    if (!( this.precpred(this._ctx, 3))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 3)");
                    }
                    this.state = 1146;
                    this.match(CParser.LeftBracket);
                    this.state = 1147;
                    this.typeQualifierList(0);
                    this.state = 1148;
                    this.match(CParser.Static);
                    this.state = 1149;
                    this.assignmentExpression();
                    this.state = 1150;
                    this.match(CParser.RightBracket);
                    break;

                case 4:
                    localctx = new DirectAbstractDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directAbstractDeclarator);
                    this.state = 1152;
                    if (!( this.precpred(this._ctx, 2))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)");
                    }
                    this.state = 1153;
                    this.match(CParser.LeftBracket);
                    this.state = 1154;
                    this.match(CParser.Star);
                    this.state = 1155;
                    this.match(CParser.RightBracket);
                    break;

                case 5:
                    localctx = new DirectAbstractDeclaratorContext(this, _parentctx, _parentState);
                    this.pushNewRecursionContext(localctx, _startState, CParser.RULE_directAbstractDeclarator);
                    this.state = 1156;
                    if (!( this.precpred(this._ctx, 1))) {
                        throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                    }
                    this.state = 1157;
                    this.match(CParser.LeftParen);
                    this.state = 1159;
                    _la = this._input.LA(1);
                    if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier) {
                        this.state = 1158;
                        this.parameterTypeList();
                    }

                    this.state = 1161;
                    this.match(CParser.RightParen);
                    this.state = 1165;
                    this._errHandler.sync(this);
                    var _alt = this._interp.adaptivePredict(this._input,101,this._ctx)
                    while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
                        if(_alt===1) {
                            this.state = 1162;
                            this.gccDeclaratorExtension(); 
                        }
                        this.state = 1167;
                        this._errHandler.sync(this);
                        _alt = this._interp.adaptivePredict(this._input,101,this._ctx);
                    }

                    break;

                } 
            }
            this.state = 1172;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,103,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function TypedefNameContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typedefName;
    return this;
}

TypedefNameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypedefNameContext.prototype.constructor = TypedefNameContext;

TypedefNameContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

TypedefNameContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypedefName(this);
	}
};

TypedefNameContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypedefName(this);
	}
};




CParser.TypedefNameContext = TypedefNameContext;

CParser.prototype.typedefName = function() {

    var localctx = new TypedefNameContext(this, this._ctx, this.state);
    this.enterRule(localctx, 128, CParser.RULE_typedefName);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1173;
        this.match(CParser.Identifier);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function InitializerContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initializer;
    return this;
}

InitializerContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InitializerContext.prototype.constructor = InitializerContext;

InitializerContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

InitializerContext.prototype.initializerList = function() {
    return this.getTypedRuleContext(InitializerListContext,0);
};

InitializerContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitializer(this);
	}
};

InitializerContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitializer(this);
	}
};




CParser.InitializerContext = InitializerContext;

CParser.prototype.initializer = function() {

    var localctx = new InitializerContext(this, this._ctx, this.state);
    this.enterRule(localctx, 130, CParser.RULE_initializer);
    try {
        this.state = 1185;
        var la_ = this._interp.adaptivePredict(this._input,104,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1175;
            this.assignmentExpression();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1176;
            this.match(CParser.LeftBrace);
            this.state = 1177;
            this.initializerList(0);
            this.state = 1178;
            this.match(CParser.RightBrace);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1180;
            this.match(CParser.LeftBrace);
            this.state = 1181;
            this.initializerList(0);
            this.state = 1182;
            this.match(CParser.Comma);
            this.state = 1183;
            this.match(CParser.RightBrace);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function InitializerListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initializerList;
    return this;
}

InitializerListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InitializerListContext.prototype.constructor = InitializerListContext;

InitializerListContext.prototype.initializer = function() {
    return this.getTypedRuleContext(InitializerContext,0);
};

InitializerListContext.prototype.designation = function() {
    return this.getTypedRuleContext(DesignationContext,0);
};

InitializerListContext.prototype.initializerList = function() {
    return this.getTypedRuleContext(InitializerListContext,0);
};

InitializerListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitializerList(this);
	}
};

InitializerListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitializerList(this);
	}
};



CParser.prototype.initializerList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new InitializerListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 132;
    this.enterRecursionRule(localctx, 132, CParser.RULE_initializerList, _p);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1189;
        _la = this._input.LA(1);
        if(_la===CParser.LeftBracket || _la===CParser.Dot) {
            this.state = 1188;
            this.designation();
        }

        this.state = 1191;
        this.initializer();
        this._ctx.stop = this._input.LT(-1);
        this.state = 1201;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,107,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new InitializerListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_initializerList);
                this.state = 1193;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1194;
                this.match(CParser.Comma);
                this.state = 1196;
                _la = this._input.LA(1);
                if(_la===CParser.LeftBracket || _la===CParser.Dot) {
                    this.state = 1195;
                    this.designation();
                }

                this.state = 1198;
                this.initializer(); 
            }
            this.state = 1203;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,107,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function DesignationContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_designation;
    return this;
}

DesignationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DesignationContext.prototype.constructor = DesignationContext;

DesignationContext.prototype.designatorList = function() {
    return this.getTypedRuleContext(DesignatorListContext,0);
};

DesignationContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDesignation(this);
	}
};

DesignationContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDesignation(this);
	}
};




CParser.DesignationContext = DesignationContext;

CParser.prototype.designation = function() {

    var localctx = new DesignationContext(this, this._ctx, this.state);
    this.enterRule(localctx, 134, CParser.RULE_designation);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1204;
        this.designatorList(0);
        this.state = 1205;
        this.match(CParser.Assign);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DesignatorListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_designatorList;
    return this;
}

DesignatorListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DesignatorListContext.prototype.constructor = DesignatorListContext;

DesignatorListContext.prototype.designator = function() {
    return this.getTypedRuleContext(DesignatorContext,0);
};

DesignatorListContext.prototype.designatorList = function() {
    return this.getTypedRuleContext(DesignatorListContext,0);
};

DesignatorListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDesignatorList(this);
	}
};

DesignatorListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDesignatorList(this);
	}
};



CParser.prototype.designatorList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new DesignatorListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 136;
    this.enterRecursionRule(localctx, 136, CParser.RULE_designatorList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1208;
        this.designator();
        this._ctx.stop = this._input.LT(-1);
        this.state = 1214;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,108,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new DesignatorListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_designatorList);
                this.state = 1210;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1211;
                this.designator(); 
            }
            this.state = 1216;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,108,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function DesignatorContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_designator;
    return this;
}

DesignatorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DesignatorContext.prototype.constructor = DesignatorContext;

DesignatorContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

DesignatorContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

DesignatorContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDesignator(this);
	}
};

DesignatorContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDesignator(this);
	}
};




CParser.DesignatorContext = DesignatorContext;

CParser.prototype.designator = function() {

    var localctx = new DesignatorContext(this, this._ctx, this.state);
    this.enterRule(localctx, 138, CParser.RULE_designator);
    try {
        this.state = 1223;
        switch(this._input.LA(1)) {
        case CParser.LeftBracket:
            this.enterOuterAlt(localctx, 1);
            this.state = 1217;
            this.match(CParser.LeftBracket);
            this.state = 1218;
            this.constantExpression();
            this.state = 1219;
            this.match(CParser.RightBracket);
            break;
        case CParser.Dot:
            this.enterOuterAlt(localctx, 2);
            this.state = 1221;
            this.match(CParser.Dot);
            this.state = 1222;
            this.match(CParser.Identifier);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StaticAssertDeclarationContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_staticAssertDeclaration;
    return this;
}

StaticAssertDeclarationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StaticAssertDeclarationContext.prototype.constructor = StaticAssertDeclarationContext;

StaticAssertDeclarationContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

StaticAssertDeclarationContext.prototype.StringLiteral = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.StringLiteral);
    } else {
        return this.getToken(CParser.StringLiteral, i);
    }
};


StaticAssertDeclarationContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStaticAssertDeclaration(this);
	}
};

StaticAssertDeclarationContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStaticAssertDeclaration(this);
	}
};




CParser.StaticAssertDeclarationContext = StaticAssertDeclarationContext;

CParser.prototype.staticAssertDeclaration = function() {

    var localctx = new StaticAssertDeclarationContext(this, this._ctx, this.state);
    this.enterRule(localctx, 140, CParser.RULE_staticAssertDeclaration);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1225;
        this.match(CParser.StaticAssert);
        this.state = 1226;
        this.match(CParser.LeftParen);
        this.state = 1227;
        this.constantExpression();
        this.state = 1228;
        this.match(CParser.Comma);
        this.state = 1230; 
        this._errHandler.sync(this);
        _la = this._input.LA(1);
        do {
            this.state = 1229;
            this.match(CParser.StringLiteral);
            this.state = 1232; 
            this._errHandler.sync(this);
            _la = this._input.LA(1);
        } while(_la===CParser.StringLiteral);
        this.state = 1234;
        this.match(CParser.RightParen);
        this.state = 1235;
        this.match(CParser.Semi);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StatementContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_statement;
    return this;
}

StatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StatementContext.prototype.constructor = StatementContext;

StatementContext.prototype.labeledStatement = function() {
    return this.getTypedRuleContext(LabeledStatementContext,0);
};

StatementContext.prototype.compoundStatement = function() {
    return this.getTypedRuleContext(CompoundStatementContext,0);
};

StatementContext.prototype.expressionStatement = function() {
    return this.getTypedRuleContext(ExpressionStatementContext,0);
};

StatementContext.prototype.selectionStatement = function() {
    return this.getTypedRuleContext(SelectionStatementContext,0);
};

StatementContext.prototype.iterationStatement = function() {
    return this.getTypedRuleContext(IterationStatementContext,0);
};

StatementContext.prototype.jumpStatement = function() {
    return this.getTypedRuleContext(JumpStatementContext,0);
};

StatementContext.prototype.logicalOrExpression = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(LogicalOrExpressionContext);
    } else {
        return this.getTypedRuleContext(LogicalOrExpressionContext,i);
    }
};

StatementContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStatement(this);
	}
};

StatementContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStatement(this);
	}
};




CParser.StatementContext = StatementContext;

CParser.prototype.statement = function() {

    var localctx = new StatementContext(this, this._ctx, this.state);
    this.enterRule(localctx, 142, CParser.RULE_statement);
    var _la = 0; // Token type
    try {
        this.state = 1274;
        var la_ = this._interp.adaptivePredict(this._input,116,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1237;
            this.labeledStatement();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1238;
            this.compoundStatement();
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1239;
            this.expressionStatement();
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1240;
            this.selectionStatement();
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 1241;
            this.iterationStatement();
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 1242;
            this.jumpStatement();
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 1243;
            _la = this._input.LA(1);
            if(!(_la===CParser.T__10 || _la===CParser.T__12)) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 1244;
            _la = this._input.LA(1);
            if(!(_la===CParser.T__13 || _la===CParser.Volatile)) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 1245;
            this.match(CParser.LeftParen);
            this.state = 1254;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1246;
                this.logicalOrExpression(0);
                this.state = 1251;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
                while(_la===CParser.Comma) {
                    this.state = 1247;
                    this.match(CParser.Comma);
                    this.state = 1248;
                    this.logicalOrExpression(0);
                    this.state = 1253;
                    this._errHandler.sync(this);
                    _la = this._input.LA(1);
                }
            }

            this.state = 1269;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.Colon) {
                this.state = 1256;
                this.match(CParser.Colon);
                this.state = 1265;
                _la = this._input.LA(1);
                if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                    this.state = 1257;
                    this.logicalOrExpression(0);
                    this.state = 1262;
                    this._errHandler.sync(this);
                    _la = this._input.LA(1);
                    while(_la===CParser.Comma) {
                        this.state = 1258;
                        this.match(CParser.Comma);
                        this.state = 1259;
                        this.logicalOrExpression(0);
                        this.state = 1264;
                        this._errHandler.sync(this);
                        _la = this._input.LA(1);
                    }
                }

                this.state = 1271;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            this.state = 1272;
            this.match(CParser.RightParen);
            this.state = 1273;
            this.match(CParser.Semi);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function LabeledStatementContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_labeledStatement;
    return this;
}

LabeledStatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
LabeledStatementContext.prototype.constructor = LabeledStatementContext;

LabeledStatementContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

LabeledStatementContext.prototype.statement = function() {
    return this.getTypedRuleContext(StatementContext,0);
};

LabeledStatementContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

LabeledStatementContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterLabeledStatement(this);
	}
};

LabeledStatementContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitLabeledStatement(this);
	}
};




CParser.LabeledStatementContext = LabeledStatementContext;

CParser.prototype.labeledStatement = function() {

    var localctx = new LabeledStatementContext(this, this._ctx, this.state);
    this.enterRule(localctx, 144, CParser.RULE_labeledStatement);
    try {
        this.state = 1287;
        switch(this._input.LA(1)) {
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 1276;
            this.match(CParser.Identifier);
            this.state = 1277;
            this.match(CParser.Colon);
            this.state = 1278;
            this.statement();
            break;
        case CParser.Case:
            this.enterOuterAlt(localctx, 2);
            this.state = 1279;
            this.match(CParser.Case);
            this.state = 1280;
            this.constantExpression();
            this.state = 1281;
            this.match(CParser.Colon);
            this.state = 1282;
            this.statement();
            break;
        case CParser.Default:
            this.enterOuterAlt(localctx, 3);
            this.state = 1284;
            this.match(CParser.Default);
            this.state = 1285;
            this.match(CParser.Colon);
            this.state = 1286;
            this.statement();
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function CompoundStatementContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_compoundStatement;
    return this;
}

CompoundStatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
CompoundStatementContext.prototype.constructor = CompoundStatementContext;

CompoundStatementContext.prototype.blockItemList = function() {
    return this.getTypedRuleContext(BlockItemListContext,0);
};

CompoundStatementContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterCompoundStatement(this);
	}
};

CompoundStatementContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitCompoundStatement(this);
	}
};




CParser.CompoundStatementContext = CompoundStatementContext;

CParser.prototype.compoundStatement = function() {

    var localctx = new CompoundStatementContext(this, this._ctx, this.state);
    this.enterRule(localctx, 146, CParser.RULE_compoundStatement);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1289;
        this.match(CParser.LeftBrace);
        this.state = 1291;
        _la = this._input.LA(1);
        if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Return - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Sizeof - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Switch - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.While - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Alignof - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Generic - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)) | (1 << (CParser.LeftParen - 32)) | (1 << (CParser.LeftBrace - 32)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Semi - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
            this.state = 1290;
            this.blockItemList(0);
        }

        this.state = 1293;
        this.match(CParser.RightBrace);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function BlockItemListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_blockItemList;
    return this;
}

BlockItemListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
BlockItemListContext.prototype.constructor = BlockItemListContext;

BlockItemListContext.prototype.blockItem = function() {
    return this.getTypedRuleContext(BlockItemContext,0);
};

BlockItemListContext.prototype.blockItemList = function() {
    return this.getTypedRuleContext(BlockItemListContext,0);
};

BlockItemListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterBlockItemList(this);
	}
};

BlockItemListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitBlockItemList(this);
	}
};



CParser.prototype.blockItemList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new BlockItemListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 148;
    this.enterRecursionRule(localctx, 148, CParser.RULE_blockItemList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1296;
        this.blockItem();
        this._ctx.stop = this._input.LT(-1);
        this.state = 1302;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,119,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new BlockItemListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_blockItemList);
                this.state = 1298;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1299;
                this.blockItem(); 
            }
            this.state = 1304;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,119,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function BlockItemContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_blockItem;
    return this;
}

BlockItemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
BlockItemContext.prototype.constructor = BlockItemContext;

BlockItemContext.prototype.specialMethodCall = function() {
    return this.getTypedRuleContext(SpecialMethodCallContext,0);
};

BlockItemContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

BlockItemContext.prototype.statement = function() {
    return this.getTypedRuleContext(StatementContext,0);
};

BlockItemContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterBlockItem(this);
	}
};

BlockItemContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitBlockItem(this);
	}
};




CParser.BlockItemContext = BlockItemContext;

CParser.prototype.blockItem = function() {

    var localctx = new BlockItemContext(this, this._ctx, this.state);
    this.enterRule(localctx, 150, CParser.RULE_blockItem);
    try {
        this.state = 1308;
        var la_ = this._interp.adaptivePredict(this._input,120,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1305;
            this.specialMethodCall();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1306;
            this.declaration();
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1307;
            this.statement();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function SpecialMethodCallContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_specialMethodCall;
    return this;
}

SpecialMethodCallContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
SpecialMethodCallContext.prototype.constructor = SpecialMethodCallContext;

SpecialMethodCallContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

SpecialMethodCallContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

SpecialMethodCallContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterSpecialMethodCall(this);
	}
};

SpecialMethodCallContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitSpecialMethodCall(this);
	}
};




CParser.SpecialMethodCallContext = SpecialMethodCallContext;

CParser.prototype.specialMethodCall = function() {

    var localctx = new SpecialMethodCallContext(this, this._ctx, this.state);
    this.enterRule(localctx, 152, CParser.RULE_specialMethodCall);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1310;
        this.match(CParser.Identifier);
        this.state = 1311;
        this.match(CParser.LeftParen);
        this.state = 1312;
        this.assignmentExpression();
        this.state = 1313;
        this.match(CParser.RightParen);
        this.state = 1314;
        this.match(CParser.Semi);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ExpressionStatementContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_expressionStatement;
    return this;
}

ExpressionStatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ExpressionStatementContext.prototype.constructor = ExpressionStatementContext;

ExpressionStatementContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

ExpressionStatementContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExpressionStatement(this);
	}
};

ExpressionStatementContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExpressionStatement(this);
	}
};




CParser.ExpressionStatementContext = ExpressionStatementContext;

CParser.prototype.expressionStatement = function() {

    var localctx = new ExpressionStatementContext(this, this._ctx, this.state);
    this.enterRule(localctx, 154, CParser.RULE_expressionStatement);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1317;
        _la = this._input.LA(1);
        if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
            this.state = 1316;
            this.expression(0);
        }

        this.state = 1319;
        this.match(CParser.Semi);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function SelectionStatementContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_selectionStatement;
    return this;
}

SelectionStatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
SelectionStatementContext.prototype.constructor = SelectionStatementContext;

SelectionStatementContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

SelectionStatementContext.prototype.statement = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(StatementContext);
    } else {
        return this.getTypedRuleContext(StatementContext,i);
    }
};

SelectionStatementContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterSelectionStatement(this);
	}
};

SelectionStatementContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitSelectionStatement(this);
	}
};




CParser.SelectionStatementContext = SelectionStatementContext;

CParser.prototype.selectionStatement = function() {

    var localctx = new SelectionStatementContext(this, this._ctx, this.state);
    this.enterRule(localctx, 156, CParser.RULE_selectionStatement);
    try {
        this.state = 1336;
        switch(this._input.LA(1)) {
        case CParser.If:
            this.enterOuterAlt(localctx, 1);
            this.state = 1321;
            this.match(CParser.If);
            this.state = 1322;
            this.match(CParser.LeftParen);
            this.state = 1323;
            this.expression(0);
            this.state = 1324;
            this.match(CParser.RightParen);
            this.state = 1325;
            this.statement();
            this.state = 1328;
            var la_ = this._interp.adaptivePredict(this._input,122,this._ctx);
            if(la_===1) {
                this.state = 1326;
                this.match(CParser.Else);
                this.state = 1327;
                this.statement();

            }
            break;
        case CParser.Switch:
            this.enterOuterAlt(localctx, 2);
            this.state = 1330;
            this.match(CParser.Switch);
            this.state = 1331;
            this.match(CParser.LeftParen);
            this.state = 1332;
            this.expression(0);
            this.state = 1333;
            this.match(CParser.RightParen);
            this.state = 1334;
            this.statement();
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function IterationStatementContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_iterationStatement;
    return this;
}

IterationStatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
IterationStatementContext.prototype.constructor = IterationStatementContext;

IterationStatementContext.prototype.expression = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(ExpressionContext);
    } else {
        return this.getTypedRuleContext(ExpressionContext,i);
    }
};

IterationStatementContext.prototype.statement = function() {
    return this.getTypedRuleContext(StatementContext,0);
};

IterationStatementContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

IterationStatementContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterIterationStatement(this);
	}
};

IterationStatementContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitIterationStatement(this);
	}
};




CParser.IterationStatementContext = IterationStatementContext;

CParser.prototype.iterationStatement = function() {

    var localctx = new IterationStatementContext(this, this._ctx, this.state);
    this.enterRule(localctx, 158, CParser.RULE_iterationStatement);
    var _la = 0; // Token type
    try {
        this.state = 1380;
        var la_ = this._interp.adaptivePredict(this._input,129,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1338;
            this.match(CParser.While);
            this.state = 1339;
            this.match(CParser.LeftParen);
            this.state = 1340;
            this.expression(0);
            this.state = 1341;
            this.match(CParser.RightParen);
            this.state = 1342;
            this.statement();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1344;
            this.match(CParser.Do);
            this.state = 1345;
            this.statement();
            this.state = 1346;
            this.match(CParser.While);
            this.state = 1347;
            this.match(CParser.LeftParen);
            this.state = 1348;
            this.expression(0);
            this.state = 1349;
            this.match(CParser.RightParen);
            this.state = 1350;
            this.match(CParser.Semi);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1352;
            this.match(CParser.For);
            this.state = 1353;
            this.match(CParser.LeftParen);
            this.state = 1355;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1354;
                this.expression(0);
            }

            this.state = 1357;
            this.match(CParser.Semi);
            this.state = 1359;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1358;
                this.expression(0);
            }

            this.state = 1361;
            this.match(CParser.Semi);
            this.state = 1363;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1362;
                this.expression(0);
            }

            this.state = 1365;
            this.match(CParser.RightParen);
            this.state = 1366;
            this.statement();
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1367;
            this.match(CParser.For);
            this.state = 1368;
            this.match(CParser.LeftParen);
            this.state = 1369;
            this.declaration();
            this.state = 1371;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1370;
                this.expression(0);
            }

            this.state = 1373;
            this.match(CParser.Semi);
            this.state = 1375;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1374;
                this.expression(0);
            }

            this.state = 1377;
            this.match(CParser.RightParen);
            this.state = 1378;
            this.statement();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function JumpStatementContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_jumpStatement;
    return this;
}

JumpStatementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
JumpStatementContext.prototype.constructor = JumpStatementContext;

JumpStatementContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

JumpStatementContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

JumpStatementContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

JumpStatementContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterJumpStatement(this);
	}
};

JumpStatementContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitJumpStatement(this);
	}
};




CParser.JumpStatementContext = JumpStatementContext;

CParser.prototype.jumpStatement = function() {

    var localctx = new JumpStatementContext(this, this._ctx, this.state);
    this.enterRule(localctx, 160, CParser.RULE_jumpStatement);
    var _la = 0; // Token type
    try {
        this.state = 1398;
        var la_ = this._interp.adaptivePredict(this._input,131,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1382;
            this.match(CParser.Goto);
            this.state = 1383;
            this.match(CParser.Identifier);
            this.state = 1384;
            this.match(CParser.Semi);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1385;
            this.match(CParser.Continue);
            this.state = 1386;
            this.match(CParser.Semi);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1387;
            this.match(CParser.Break);
            this.state = 1388;
            this.match(CParser.Semi);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1389;
            this.match(CParser.Return);
            this.state = 1391;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1390;
                this.expression(0);
            }

            this.state = 1393;
            this.match(CParser.Semi);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 1394;
            this.match(CParser.Goto);
            this.state = 1395;
            this.unaryExpression();
            this.state = 1396;
            this.match(CParser.Semi);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function CompilationUnitContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_compilationUnit;
    return this;
}

CompilationUnitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
CompilationUnitContext.prototype.constructor = CompilationUnitContext;

CompilationUnitContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

CompilationUnitContext.prototype.translationUnit = function() {
    return this.getTypedRuleContext(TranslationUnitContext,0);
};

CompilationUnitContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterCompilationUnit(this);
	}
};

CompilationUnitContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitCompilationUnit(this);
	}
};




CParser.CompilationUnitContext = CompilationUnitContext;

CParser.prototype.compilationUnit = function() {

    var localctx = new CompilationUnitContext(this, this._ctx, this.state);
    this.enterRule(localctx, 162, CParser.RULE_compilationUnit);
    var _la = 0; // Token type
    try {
        this.state = 1405;
        var la_ = this._interp.adaptivePredict(this._input,133,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1401;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)) | (1 << (CParser.LeftParen - 32)))) !== 0) || ((((_la - 75)) & ~0x1f) == 0 && ((1 << (_la - 75)) & ((1 << (CParser.Star - 75)) | (1 << (CParser.Caret - 75)) | (1 << (CParser.Semi - 75)) | (1 << (CParser.Identifier - 75)))) !== 0)) {
                this.state = 1400;
                this.translationUnit(0);
            }

            this.state = 1403;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1404;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TranslationUnitContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_translationUnit;
    return this;
}

TranslationUnitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TranslationUnitContext.prototype.constructor = TranslationUnitContext;

TranslationUnitContext.prototype.externalDeclaration = function() {
    return this.getTypedRuleContext(ExternalDeclarationContext,0);
};

TranslationUnitContext.prototype.translationUnit = function() {
    return this.getTypedRuleContext(TranslationUnitContext,0);
};

TranslationUnitContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTranslationUnit(this);
	}
};

TranslationUnitContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTranslationUnit(this);
	}
};



CParser.prototype.translationUnit = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new TranslationUnitContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 164;
    this.enterRecursionRule(localctx, 164, CParser.RULE_translationUnit, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1408;
        this.externalDeclaration();
        this._ctx.stop = this._input.LT(-1);
        this.state = 1414;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,134,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new TranslationUnitContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_translationUnit);
                this.state = 1410;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1411;
                this.externalDeclaration(); 
            }
            this.state = 1416;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,134,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function ExternalDeclarationContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_externalDeclaration;
    return this;
}

ExternalDeclarationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ExternalDeclarationContext.prototype.constructor = ExternalDeclarationContext;

ExternalDeclarationContext.prototype.functionDefinition = function() {
    return this.getTypedRuleContext(FunctionDefinitionContext,0);
};

ExternalDeclarationContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

ExternalDeclarationContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExternalDeclaration(this);
	}
};

ExternalDeclarationContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExternalDeclaration(this);
	}
};




CParser.ExternalDeclarationContext = ExternalDeclarationContext;

CParser.prototype.externalDeclaration = function() {

    var localctx = new ExternalDeclarationContext(this, this._ctx, this.state);
    this.enterRule(localctx, 166, CParser.RULE_externalDeclaration);
    try {
        this.state = 1420;
        var la_ = this._interp.adaptivePredict(this._input,135,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1417;
            this.functionDefinition();
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1418;
            this.declaration();
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1419;
            this.match(CParser.Semi);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function FunctionDefinitionContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_functionDefinition;
    return this;
}

FunctionDefinitionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
FunctionDefinitionContext.prototype.constructor = FunctionDefinitionContext;

FunctionDefinitionContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

FunctionDefinitionContext.prototype.compoundStatement = function() {
    return this.getTypedRuleContext(CompoundStatementContext,0);
};

FunctionDefinitionContext.prototype.declarationSpecifiers = function() {
    return this.getTypedRuleContext(DeclarationSpecifiersContext,0);
};

FunctionDefinitionContext.prototype.declarationList = function() {
    return this.getTypedRuleContext(DeclarationListContext,0);
};

FunctionDefinitionContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterFunctionDefinition(this);
	}
};

FunctionDefinitionContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitFunctionDefinition(this);
	}
};




CParser.FunctionDefinitionContext = FunctionDefinitionContext;

CParser.prototype.functionDefinition = function() {

    var localctx = new FunctionDefinitionContext(this, this._ctx, this.state);
    this.enterRule(localctx, 168, CParser.RULE_functionDefinition);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1423;
        var la_ = this._interp.adaptivePredict(this._input,136,this._ctx);
        if(la_===1) {
            this.state = 1422;
            this.declarationSpecifiers();

        }
        this.state = 1425;
        this.declarator();
        this.state = 1427;
        _la = this._input.LA(1);
        if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier) {
            this.state = 1426;
            this.declarationList(0);
        }

        this.state = 1429;
        this.compoundStatement();
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationListContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationList;
    return this;
}

DeclarationListContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationListContext.prototype.constructor = DeclarationListContext;

DeclarationListContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

DeclarationListContext.prototype.declarationList = function() {
    return this.getTypedRuleContext(DeclarationListContext,0);
};

DeclarationListContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationList(this);
	}
};

DeclarationListContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationList(this);
	}
};



CParser.prototype.declarationList = function(_p) {
	if(_p===undefined) {
	    _p = 0;
	}
    var _parentctx = this._ctx;
    var _parentState = this.state;
    var localctx = new DeclarationListContext(this, this._ctx, _parentState);
    var _prevctx = localctx;
    var _startState = 170;
    this.enterRecursionRule(localctx, 170, CParser.RULE_declarationList, _p);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1432;
        this.declaration();
        this._ctx.stop = this._input.LT(-1);
        this.state = 1438;
        this._errHandler.sync(this);
        var _alt = this._interp.adaptivePredict(this._input,138,this._ctx)
        while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) {
            if(_alt===1) {
                if(this._parseListeners!==null) {
                    this.triggerExitRuleEvent();
                }
                _prevctx = localctx;
                localctx = new DeclarationListContext(this, _parentctx, _parentState);
                this.pushNewRecursionContext(localctx, _startState, CParser.RULE_declarationList);
                this.state = 1434;
                if (!( this.precpred(this._ctx, 1))) {
                    throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)");
                }
                this.state = 1435;
                this.declaration(); 
            }
            this.state = 1440;
            this._errHandler.sync(this);
            _alt = this._interp.adaptivePredict(this._input,138,this._ctx);
        }

    } catch( error) {
        if(error instanceof antlr4.error.RecognitionException) {
	        localctx.exception = error;
	        this._errHandler.reportError(this, error);
	        this._errHandler.recover(this, error);
	    } else {
	    	throw error;
	    }
    } finally {
        this.unrollRecursionContexts(_parentctx)
    }
    return localctx;
};

function PrimaryExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_primaryExpression_DropletFile;
    return this;
}

PrimaryExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
PrimaryExpression_DropletFileContext.prototype.constructor = PrimaryExpression_DropletFileContext;

PrimaryExpression_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

PrimaryExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

PrimaryExpression_DropletFileContext.prototype.Constant = function() {
    return this.getToken(CParser.Constant, 0);
};

PrimaryExpression_DropletFileContext.prototype.StringLiteral = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.StringLiteral);
    } else {
        return this.getToken(CParser.StringLiteral, i);
    }
};


PrimaryExpression_DropletFileContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

PrimaryExpression_DropletFileContext.prototype.genericSelection = function() {
    return this.getTypedRuleContext(GenericSelectionContext,0);
};

PrimaryExpression_DropletFileContext.prototype.compoundStatement = function() {
    return this.getTypedRuleContext(CompoundStatementContext,0);
};

PrimaryExpression_DropletFileContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

PrimaryExpression_DropletFileContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

PrimaryExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterPrimaryExpression_DropletFile(this);
	}
};

PrimaryExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitPrimaryExpression_DropletFile(this);
	}
};




CParser.PrimaryExpression_DropletFileContext = PrimaryExpression_DropletFileContext;

CParser.prototype.primaryExpression_DropletFile = function() {

    var localctx = new PrimaryExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 172, CParser.RULE_primaryExpression_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 1482;
        var la_ = this._interp.adaptivePredict(this._input,141,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1441;
            this.match(CParser.Identifier);
            this.state = 1442;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1443;
            this.match(CParser.Constant);
            this.state = 1444;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1446; 
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            do {
                this.state = 1445;
                this.match(CParser.StringLiteral);
                this.state = 1448; 
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            } while(_la===CParser.StringLiteral);
            this.state = 1450;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1451;
            this.match(CParser.LeftParen);
            this.state = 1452;
            this.expression(0);
            this.state = 1453;
            this.match(CParser.RightParen);
            this.state = 1454;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 1456;
            this.genericSelection();
            this.state = 1457;
            this.match(CParser.EOF);
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 1460;
            _la = this._input.LA(1);
            if(_la===CParser.T__0) {
                this.state = 1459;
                this.match(CParser.T__0);
            }

            this.state = 1462;
            this.match(CParser.LeftParen);
            this.state = 1463;
            this.compoundStatement();
            this.state = 1464;
            this.match(CParser.RightParen);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 1466;
            this.match(CParser.T__1);
            this.state = 1467;
            this.match(CParser.LeftParen);
            this.state = 1468;
            this.unaryExpression();
            this.state = 1469;
            this.match(CParser.Comma);
            this.state = 1470;
            this.typeName();
            this.state = 1471;
            this.match(CParser.RightParen);
            this.state = 1472;
            this.match(CParser.EOF);
            break;

        case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 1474;
            this.match(CParser.T__2);
            this.state = 1475;
            this.match(CParser.LeftParen);
            this.state = 1476;
            this.typeName();
            this.state = 1477;
            this.match(CParser.Comma);
            this.state = 1478;
            this.unaryExpression();
            this.state = 1479;
            this.match(CParser.RightParen);
            this.state = 1480;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GenericSelection_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_genericSelection_DropletFile;
    return this;
}

GenericSelection_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GenericSelection_DropletFileContext.prototype.constructor = GenericSelection_DropletFileContext;

GenericSelection_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

GenericSelection_DropletFileContext.prototype.genericAssocList = function() {
    return this.getTypedRuleContext(GenericAssocListContext,0);
};

GenericSelection_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

GenericSelection_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGenericSelection_DropletFile(this);
	}
};

GenericSelection_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGenericSelection_DropletFile(this);
	}
};




CParser.GenericSelection_DropletFileContext = GenericSelection_DropletFileContext;

CParser.prototype.genericSelection_DropletFile = function() {

    var localctx = new GenericSelection_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 174, CParser.RULE_genericSelection_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1484;
        this.match(CParser.Generic);
        this.state = 1485;
        this.match(CParser.LeftParen);
        this.state = 1486;
        this.assignmentExpression();
        this.state = 1487;
        this.match(CParser.Comma);
        this.state = 1488;
        this.genericAssocList(0);
        this.state = 1489;
        this.match(CParser.RightParen);
        this.state = 1490;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GenericAssocList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_genericAssocList_DropletFile;
    return this;
}

GenericAssocList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GenericAssocList_DropletFileContext.prototype.constructor = GenericAssocList_DropletFileContext;

GenericAssocList_DropletFileContext.prototype.genericAssociation = function() {
    return this.getTypedRuleContext(GenericAssociationContext,0);
};

GenericAssocList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

GenericAssocList_DropletFileContext.prototype.genericAssocList = function() {
    return this.getTypedRuleContext(GenericAssocListContext,0);
};

GenericAssocList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGenericAssocList_DropletFile(this);
	}
};

GenericAssocList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGenericAssocList_DropletFile(this);
	}
};




CParser.GenericAssocList_DropletFileContext = GenericAssocList_DropletFileContext;

CParser.prototype.genericAssocList_DropletFile = function() {

    var localctx = new GenericAssocList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 176, CParser.RULE_genericAssocList_DropletFile);
    try {
        this.state = 1500;
        var la_ = this._interp.adaptivePredict(this._input,142,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1492;
            this.genericAssociation();
            this.state = 1493;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1495;
            this.genericAssocList(0);
            this.state = 1496;
            this.match(CParser.Comma);
            this.state = 1497;
            this.genericAssociation();
            this.state = 1498;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GenericAssociation_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_genericAssociation_DropletFile;
    return this;
}

GenericAssociation_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GenericAssociation_DropletFileContext.prototype.constructor = GenericAssociation_DropletFileContext;

GenericAssociation_DropletFileContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

GenericAssociation_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

GenericAssociation_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

GenericAssociation_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGenericAssociation_DropletFile(this);
	}
};

GenericAssociation_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGenericAssociation_DropletFile(this);
	}
};




CParser.GenericAssociation_DropletFileContext = GenericAssociation_DropletFileContext;

CParser.prototype.genericAssociation_DropletFile = function() {

    var localctx = new GenericAssociation_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 178, CParser.RULE_genericAssociation_DropletFile);
    try {
        this.state = 1512;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.Char:
        case CParser.Const:
        case CParser.Double:
        case CParser.Enum:
        case CParser.Float:
        case CParser.Int:
        case CParser.Long:
        case CParser.Restrict:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Struct:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 1502;
            this.typeName();
            this.state = 1503;
            this.match(CParser.Colon);
            this.state = 1504;
            this.assignmentExpression();
            this.state = 1505;
            this.match(CParser.EOF);
            break;
        case CParser.Default:
            this.enterOuterAlt(localctx, 2);
            this.state = 1507;
            this.match(CParser.Default);
            this.state = 1508;
            this.match(CParser.Colon);
            this.state = 1509;
            this.assignmentExpression();
            this.state = 1510;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function PostfixExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_postfixExpression_DropletFile;
    return this;
}

PostfixExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
PostfixExpression_DropletFileContext.prototype.constructor = PostfixExpression_DropletFileContext;

PostfixExpression_DropletFileContext.prototype.primaryExpression = function() {
    return this.getTypedRuleContext(PrimaryExpressionContext,0);
};

PostfixExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

PostfixExpression_DropletFileContext.prototype.postfixExpression = function() {
    return this.getTypedRuleContext(PostfixExpressionContext,0);
};

PostfixExpression_DropletFileContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

PostfixExpression_DropletFileContext.prototype.argumentExpressionList = function() {
    return this.getTypedRuleContext(ArgumentExpressionListContext,0);
};

PostfixExpression_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

PostfixExpression_DropletFileContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

PostfixExpression_DropletFileContext.prototype.initializerList = function() {
    return this.getTypedRuleContext(InitializerListContext,0);
};

PostfixExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterPostfixExpression_DropletFile(this);
	}
};

PostfixExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitPostfixExpression_DropletFile(this);
	}
};




CParser.PostfixExpression_DropletFileContext = PostfixExpression_DropletFileContext;

CParser.prototype.postfixExpression_DropletFile = function() {

    var localctx = new PostfixExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 180, CParser.RULE_postfixExpression_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 1585;
        var la_ = this._interp.adaptivePredict(this._input,145,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1514;
            this.primaryExpression();
            this.state = 1515;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1517;
            this.postfixExpression(0);
            this.state = 1518;
            this.match(CParser.LeftBracket);
            this.state = 1519;
            this.expression(0);
            this.state = 1520;
            this.match(CParser.RightBracket);
            this.state = 1521;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1523;
            this.postfixExpression(0);
            this.state = 1524;
            this.match(CParser.LeftParen);
            this.state = 1526;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 1525;
                this.argumentExpressionList(0);
            }

            this.state = 1528;
            this.match(CParser.RightParen);
            this.state = 1529;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1531;
            this.postfixExpression(0);
            this.state = 1532;
            this.match(CParser.Dot);
            this.state = 1533;
            this.match(CParser.Identifier);
            this.state = 1534;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 1536;
            this.postfixExpression(0);
            this.state = 1537;
            this.match(CParser.Arrow);
            this.state = 1538;
            this.match(CParser.Identifier);
            this.state = 1539;
            this.match(CParser.EOF);
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 1541;
            this.postfixExpression(0);
            this.state = 1542;
            this.match(CParser.PlusPlus);
            this.state = 1543;
            this.match(CParser.EOF);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 1545;
            this.postfixExpression(0);
            this.state = 1546;
            this.match(CParser.MinusMinus);
            this.state = 1547;
            this.match(CParser.EOF);
            break;

        case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 1549;
            this.match(CParser.LeftParen);
            this.state = 1550;
            this.typeName();
            this.state = 1551;
            this.match(CParser.RightParen);
            this.state = 1552;
            this.match(CParser.LeftBrace);
            this.state = 1553;
            this.initializerList(0);
            this.state = 1554;
            this.match(CParser.RightBrace);
            this.state = 1555;
            this.match(CParser.EOF);
            break;

        case 9:
            this.enterOuterAlt(localctx, 9);
            this.state = 1557;
            this.match(CParser.LeftParen);
            this.state = 1558;
            this.typeName();
            this.state = 1559;
            this.match(CParser.RightParen);
            this.state = 1560;
            this.match(CParser.LeftBrace);
            this.state = 1561;
            this.initializerList(0);
            this.state = 1562;
            this.match(CParser.Comma);
            this.state = 1563;
            this.match(CParser.RightBrace);
            this.state = 1564;
            this.match(CParser.EOF);
            break;

        case 10:
            this.enterOuterAlt(localctx, 10);
            this.state = 1566;
            this.match(CParser.T__0);
            this.state = 1567;
            this.match(CParser.LeftParen);
            this.state = 1568;
            this.typeName();
            this.state = 1569;
            this.match(CParser.RightParen);
            this.state = 1570;
            this.match(CParser.LeftBrace);
            this.state = 1571;
            this.initializerList(0);
            this.state = 1572;
            this.match(CParser.RightBrace);
            this.state = 1573;
            this.match(CParser.EOF);
            break;

        case 11:
            this.enterOuterAlt(localctx, 11);
            this.state = 1575;
            this.match(CParser.T__0);
            this.state = 1576;
            this.match(CParser.LeftParen);
            this.state = 1577;
            this.typeName();
            this.state = 1578;
            this.match(CParser.RightParen);
            this.state = 1579;
            this.match(CParser.LeftBrace);
            this.state = 1580;
            this.initializerList(0);
            this.state = 1581;
            this.match(CParser.Comma);
            this.state = 1582;
            this.match(CParser.RightBrace);
            this.state = 1583;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ArgumentExpressionList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_argumentExpressionList_DropletFile;
    return this;
}

ArgumentExpressionList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ArgumentExpressionList_DropletFileContext.prototype.constructor = ArgumentExpressionList_DropletFileContext;

ArgumentExpressionList_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

ArgumentExpressionList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ArgumentExpressionList_DropletFileContext.prototype.argumentExpressionList = function() {
    return this.getTypedRuleContext(ArgumentExpressionListContext,0);
};

ArgumentExpressionList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterArgumentExpressionList_DropletFile(this);
	}
};

ArgumentExpressionList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitArgumentExpressionList_DropletFile(this);
	}
};




CParser.ArgumentExpressionList_DropletFileContext = ArgumentExpressionList_DropletFileContext;

CParser.prototype.argumentExpressionList_DropletFile = function() {

    var localctx = new ArgumentExpressionList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 182, CParser.RULE_argumentExpressionList_DropletFile);
    try {
        this.state = 1595;
        var la_ = this._interp.adaptivePredict(this._input,146,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1587;
            this.assignmentExpression();
            this.state = 1588;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1590;
            this.argumentExpressionList(0);
            this.state = 1591;
            this.match(CParser.Comma);
            this.state = 1592;
            this.assignmentExpression();
            this.state = 1593;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function UnaryExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_unaryExpression_DropletFile;
    return this;
}

UnaryExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
UnaryExpression_DropletFileContext.prototype.constructor = UnaryExpression_DropletFileContext;

UnaryExpression_DropletFileContext.prototype.postfixExpression = function() {
    return this.getTypedRuleContext(PostfixExpressionContext,0);
};

UnaryExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

UnaryExpression_DropletFileContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

UnaryExpression_DropletFileContext.prototype.unaryOperator = function() {
    return this.getTypedRuleContext(UnaryOperatorContext,0);
};

UnaryExpression_DropletFileContext.prototype.castExpression = function() {
    return this.getTypedRuleContext(CastExpressionContext,0);
};

UnaryExpression_DropletFileContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

UnaryExpression_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

UnaryExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterUnaryExpression_DropletFile(this);
	}
};

UnaryExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitUnaryExpression_DropletFile(this);
	}
};




CParser.UnaryExpression_DropletFileContext = UnaryExpression_DropletFileContext;

CParser.prototype.unaryExpression_DropletFile = function() {

    var localctx = new UnaryExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 184, CParser.RULE_unaryExpression_DropletFile);
    try {
        this.state = 1630;
        var la_ = this._interp.adaptivePredict(this._input,147,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1597;
            this.postfixExpression(0);
            this.state = 1598;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1600;
            this.match(CParser.PlusPlus);
            this.state = 1601;
            this.unaryExpression();
            this.state = 1602;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1604;
            this.match(CParser.MinusMinus);
            this.state = 1605;
            this.unaryExpression();
            this.state = 1606;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1608;
            this.unaryOperator();
            this.state = 1609;
            this.castExpression();
            this.state = 1610;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 1612;
            this.match(CParser.Sizeof);
            this.state = 1613;
            this.unaryExpression();
            this.state = 1614;
            this.match(CParser.EOF);
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 1616;
            this.match(CParser.Sizeof);
            this.state = 1617;
            this.match(CParser.LeftParen);
            this.state = 1618;
            this.typeName();
            this.state = 1619;
            this.match(CParser.RightParen);
            this.state = 1620;
            this.match(CParser.EOF);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 1622;
            this.match(CParser.Alignof);
            this.state = 1623;
            this.match(CParser.LeftParen);
            this.state = 1624;
            this.typeName();
            this.state = 1625;
            this.match(CParser.RightParen);
            this.state = 1626;
            this.match(CParser.EOF);
            break;

        case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 1628;
            this.match(CParser.AndAnd);
            this.state = 1629;
            this.match(CParser.Identifier);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function UnaryOperator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_unaryOperator_DropletFile;
    return this;
}

UnaryOperator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
UnaryOperator_DropletFileContext.prototype.constructor = UnaryOperator_DropletFileContext;

UnaryOperator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

UnaryOperator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterUnaryOperator_DropletFile(this);
	}
};

UnaryOperator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitUnaryOperator_DropletFile(this);
	}
};




CParser.UnaryOperator_DropletFileContext = UnaryOperator_DropletFileContext;

CParser.prototype.unaryOperator_DropletFile = function() {

    var localctx = new UnaryOperator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 186, CParser.RULE_unaryOperator_DropletFile);
    try {
        this.state = 1639;
        switch(this._input.LA(1)) {
        case CParser.And:
            this.enterOuterAlt(localctx, 1);
            this.state = 1632;
            this.match(CParser.And);
            break;
        case CParser.Star:
            this.enterOuterAlt(localctx, 2);
            this.state = 1633;
            this.match(CParser.Star);
            break;
        case CParser.Plus:
            this.enterOuterAlt(localctx, 3);
            this.state = 1634;
            this.match(CParser.Plus);
            break;
        case CParser.Minus:
            this.enterOuterAlt(localctx, 4);
            this.state = 1635;
            this.match(CParser.Minus);
            break;
        case CParser.Tilde:
            this.enterOuterAlt(localctx, 5);
            this.state = 1636;
            this.match(CParser.Tilde);
            break;
        case CParser.Not:
            this.enterOuterAlt(localctx, 6);
            this.state = 1637;
            this.match(CParser.Not);
            this.state = 1638;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function CastExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_castExpression_DropletFile;
    return this;
}

CastExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
CastExpression_DropletFileContext.prototype.constructor = CastExpression_DropletFileContext;

CastExpression_DropletFileContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

CastExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

CastExpression_DropletFileContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

CastExpression_DropletFileContext.prototype.castExpression = function() {
    return this.getTypedRuleContext(CastExpressionContext,0);
};

CastExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterCastExpression_DropletFile(this);
	}
};

CastExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitCastExpression_DropletFile(this);
	}
};




CParser.CastExpression_DropletFileContext = CastExpression_DropletFileContext;

CParser.prototype.castExpression_DropletFile = function() {

    var localctx = new CastExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 188, CParser.RULE_castExpression_DropletFile);
    try {
        this.state = 1657;
        var la_ = this._interp.adaptivePredict(this._input,149,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1641;
            this.unaryExpression();
            this.state = 1642;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1644;
            this.match(CParser.LeftParen);
            this.state = 1645;
            this.typeName();
            this.state = 1646;
            this.match(CParser.RightParen);
            this.state = 1647;
            this.castExpression();
            this.state = 1648;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1650;
            this.match(CParser.T__0);
            this.state = 1651;
            this.match(CParser.LeftParen);
            this.state = 1652;
            this.typeName();
            this.state = 1653;
            this.match(CParser.RightParen);
            this.state = 1654;
            this.castExpression();
            this.state = 1655;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function MultiplicativeExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_multiplicativeExpression_DropletFile;
    return this;
}

MultiplicativeExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
MultiplicativeExpression_DropletFileContext.prototype.constructor = MultiplicativeExpression_DropletFileContext;

MultiplicativeExpression_DropletFileContext.prototype.castExpression = function() {
    return this.getTypedRuleContext(CastExpressionContext,0);
};

MultiplicativeExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

MultiplicativeExpression_DropletFileContext.prototype.multiplicativeExpression = function() {
    return this.getTypedRuleContext(MultiplicativeExpressionContext,0);
};

MultiplicativeExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterMultiplicativeExpression_DropletFile(this);
	}
};

MultiplicativeExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitMultiplicativeExpression_DropletFile(this);
	}
};




CParser.MultiplicativeExpression_DropletFileContext = MultiplicativeExpression_DropletFileContext;

CParser.prototype.multiplicativeExpression_DropletFile = function() {

    var localctx = new MultiplicativeExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 190, CParser.RULE_multiplicativeExpression_DropletFile);
    try {
        this.state = 1677;
        var la_ = this._interp.adaptivePredict(this._input,150,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1659;
            this.castExpression();
            this.state = 1660;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1662;
            this.multiplicativeExpression(0);
            this.state = 1663;
            this.match(CParser.Star);
            this.state = 1664;
            this.castExpression();
            this.state = 1665;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1667;
            this.multiplicativeExpression(0);
            this.state = 1668;
            this.match(CParser.Div);
            this.state = 1669;
            this.castExpression();
            this.state = 1670;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1672;
            this.multiplicativeExpression(0);
            this.state = 1673;
            this.match(CParser.Mod);
            this.state = 1674;
            this.castExpression();
            this.state = 1675;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AdditiveExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_additiveExpression_DropletFile;
    return this;
}

AdditiveExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AdditiveExpression_DropletFileContext.prototype.constructor = AdditiveExpression_DropletFileContext;

AdditiveExpression_DropletFileContext.prototype.multiplicativeExpression = function() {
    return this.getTypedRuleContext(MultiplicativeExpressionContext,0);
};

AdditiveExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

AdditiveExpression_DropletFileContext.prototype.additiveExpression = function() {
    return this.getTypedRuleContext(AdditiveExpressionContext,0);
};

AdditiveExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAdditiveExpression_DropletFile(this);
	}
};

AdditiveExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAdditiveExpression_DropletFile(this);
	}
};




CParser.AdditiveExpression_DropletFileContext = AdditiveExpression_DropletFileContext;

CParser.prototype.additiveExpression_DropletFile = function() {

    var localctx = new AdditiveExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 192, CParser.RULE_additiveExpression_DropletFile);
    try {
        this.state = 1692;
        var la_ = this._interp.adaptivePredict(this._input,151,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1679;
            this.multiplicativeExpression(0);
            this.state = 1680;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1682;
            this.additiveExpression(0);
            this.state = 1683;
            this.match(CParser.Plus);
            this.state = 1684;
            this.multiplicativeExpression(0);
            this.state = 1685;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1687;
            this.additiveExpression(0);
            this.state = 1688;
            this.match(CParser.Minus);
            this.state = 1689;
            this.multiplicativeExpression(0);
            this.state = 1690;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ShiftExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_shiftExpression_DropletFile;
    return this;
}

ShiftExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ShiftExpression_DropletFileContext.prototype.constructor = ShiftExpression_DropletFileContext;

ShiftExpression_DropletFileContext.prototype.additiveExpression = function() {
    return this.getTypedRuleContext(AdditiveExpressionContext,0);
};

ShiftExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ShiftExpression_DropletFileContext.prototype.shiftExpression = function() {
    return this.getTypedRuleContext(ShiftExpressionContext,0);
};

ShiftExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterShiftExpression_DropletFile(this);
	}
};

ShiftExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitShiftExpression_DropletFile(this);
	}
};




CParser.ShiftExpression_DropletFileContext = ShiftExpression_DropletFileContext;

CParser.prototype.shiftExpression_DropletFile = function() {

    var localctx = new ShiftExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 194, CParser.RULE_shiftExpression_DropletFile);
    try {
        this.state = 1707;
        var la_ = this._interp.adaptivePredict(this._input,152,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1694;
            this.additiveExpression(0);
            this.state = 1695;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1697;
            this.shiftExpression(0);
            this.state = 1698;
            this.match(CParser.LeftShift);
            this.state = 1699;
            this.additiveExpression(0);
            this.state = 1700;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1702;
            this.shiftExpression(0);
            this.state = 1703;
            this.match(CParser.RightShift);
            this.state = 1704;
            this.additiveExpression(0);
            this.state = 1705;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function RelationalExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_relationalExpression_DropletFile;
    return this;
}

RelationalExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
RelationalExpression_DropletFileContext.prototype.constructor = RelationalExpression_DropletFileContext;

RelationalExpression_DropletFileContext.prototype.shiftExpression = function() {
    return this.getTypedRuleContext(ShiftExpressionContext,0);
};

RelationalExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

RelationalExpression_DropletFileContext.prototype.relationalExpression = function() {
    return this.getTypedRuleContext(RelationalExpressionContext,0);
};

RelationalExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterRelationalExpression_DropletFile(this);
	}
};

RelationalExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitRelationalExpression_DropletFile(this);
	}
};




CParser.RelationalExpression_DropletFileContext = RelationalExpression_DropletFileContext;

CParser.prototype.relationalExpression_DropletFile = function() {

    var localctx = new RelationalExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 196, CParser.RULE_relationalExpression_DropletFile);
    try {
        this.state = 1732;
        var la_ = this._interp.adaptivePredict(this._input,153,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1709;
            this.shiftExpression(0);
            this.state = 1710;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1712;
            this.relationalExpression(0);
            this.state = 1713;
            this.match(CParser.Less);
            this.state = 1714;
            this.shiftExpression(0);
            this.state = 1715;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1717;
            this.relationalExpression(0);
            this.state = 1718;
            this.match(CParser.Greater);
            this.state = 1719;
            this.shiftExpression(0);
            this.state = 1720;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1722;
            this.relationalExpression(0);
            this.state = 1723;
            this.match(CParser.LessEqual);
            this.state = 1724;
            this.shiftExpression(0);
            this.state = 1725;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 1727;
            this.relationalExpression(0);
            this.state = 1728;
            this.match(CParser.GreaterEqual);
            this.state = 1729;
            this.shiftExpression(0);
            this.state = 1730;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function EqualityExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_equalityExpression_DropletFile;
    return this;
}

EqualityExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EqualityExpression_DropletFileContext.prototype.constructor = EqualityExpression_DropletFileContext;

EqualityExpression_DropletFileContext.prototype.relationalExpression = function() {
    return this.getTypedRuleContext(RelationalExpressionContext,0);
};

EqualityExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

EqualityExpression_DropletFileContext.prototype.equalityExpression = function() {
    return this.getTypedRuleContext(EqualityExpressionContext,0);
};

EqualityExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEqualityExpression_DropletFile(this);
	}
};

EqualityExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEqualityExpression_DropletFile(this);
	}
};




CParser.EqualityExpression_DropletFileContext = EqualityExpression_DropletFileContext;

CParser.prototype.equalityExpression_DropletFile = function() {

    var localctx = new EqualityExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 198, CParser.RULE_equalityExpression_DropletFile);
    try {
        this.state = 1747;
        var la_ = this._interp.adaptivePredict(this._input,154,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1734;
            this.relationalExpression(0);
            this.state = 1735;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1737;
            this.equalityExpression(0);
            this.state = 1738;
            this.match(CParser.Equal);
            this.state = 1739;
            this.relationalExpression(0);
            this.state = 1740;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1742;
            this.equalityExpression(0);
            this.state = 1743;
            this.match(CParser.NotEqual);
            this.state = 1744;
            this.relationalExpression(0);
            this.state = 1745;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AndExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_andExpression_DropletFile;
    return this;
}

AndExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AndExpression_DropletFileContext.prototype.constructor = AndExpression_DropletFileContext;

AndExpression_DropletFileContext.prototype.equalityExpression = function() {
    return this.getTypedRuleContext(EqualityExpressionContext,0);
};

AndExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

AndExpression_DropletFileContext.prototype.andExpression = function() {
    return this.getTypedRuleContext(AndExpressionContext,0);
};

AndExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAndExpression_DropletFile(this);
	}
};

AndExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAndExpression_DropletFile(this);
	}
};




CParser.AndExpression_DropletFileContext = AndExpression_DropletFileContext;

CParser.prototype.andExpression_DropletFile = function() {

    var localctx = new AndExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 200, CParser.RULE_andExpression_DropletFile);
    try {
        this.state = 1757;
        var la_ = this._interp.adaptivePredict(this._input,155,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1749;
            this.equalityExpression(0);
            this.state = 1750;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1752;
            this.andExpression(0);
            this.state = 1753;
            this.match(CParser.And);
            this.state = 1754;
            this.equalityExpression(0);
            this.state = 1755;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ExclusiveOrExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_exclusiveOrExpression_DropletFile;
    return this;
}

ExclusiveOrExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ExclusiveOrExpression_DropletFileContext.prototype.constructor = ExclusiveOrExpression_DropletFileContext;

ExclusiveOrExpression_DropletFileContext.prototype.andExpression = function() {
    return this.getTypedRuleContext(AndExpressionContext,0);
};

ExclusiveOrExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ExclusiveOrExpression_DropletFileContext.prototype.exclusiveOrExpression = function() {
    return this.getTypedRuleContext(ExclusiveOrExpressionContext,0);
};

ExclusiveOrExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExclusiveOrExpression_DropletFile(this);
	}
};

ExclusiveOrExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExclusiveOrExpression_DropletFile(this);
	}
};




CParser.ExclusiveOrExpression_DropletFileContext = ExclusiveOrExpression_DropletFileContext;

CParser.prototype.exclusiveOrExpression_DropletFile = function() {

    var localctx = new ExclusiveOrExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 202, CParser.RULE_exclusiveOrExpression_DropletFile);
    try {
        this.state = 1767;
        var la_ = this._interp.adaptivePredict(this._input,156,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1759;
            this.andExpression(0);
            this.state = 1760;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1762;
            this.exclusiveOrExpression(0);
            this.state = 1763;
            this.match(CParser.Caret);
            this.state = 1764;
            this.andExpression(0);
            this.state = 1765;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function InclusiveOrExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_inclusiveOrExpression_DropletFile;
    return this;
}

InclusiveOrExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InclusiveOrExpression_DropletFileContext.prototype.constructor = InclusiveOrExpression_DropletFileContext;

InclusiveOrExpression_DropletFileContext.prototype.exclusiveOrExpression = function() {
    return this.getTypedRuleContext(ExclusiveOrExpressionContext,0);
};

InclusiveOrExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

InclusiveOrExpression_DropletFileContext.prototype.inclusiveOrExpression = function() {
    return this.getTypedRuleContext(InclusiveOrExpressionContext,0);
};

InclusiveOrExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInclusiveOrExpression_DropletFile(this);
	}
};

InclusiveOrExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInclusiveOrExpression_DropletFile(this);
	}
};




CParser.InclusiveOrExpression_DropletFileContext = InclusiveOrExpression_DropletFileContext;

CParser.prototype.inclusiveOrExpression_DropletFile = function() {

    var localctx = new InclusiveOrExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 204, CParser.RULE_inclusiveOrExpression_DropletFile);
    try {
        this.state = 1777;
        var la_ = this._interp.adaptivePredict(this._input,157,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1769;
            this.exclusiveOrExpression(0);
            this.state = 1770;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1772;
            this.inclusiveOrExpression(0);
            this.state = 1773;
            this.match(CParser.Or);
            this.state = 1774;
            this.exclusiveOrExpression(0);
            this.state = 1775;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function LogicalAndExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_logicalAndExpression_DropletFile;
    return this;
}

LogicalAndExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
LogicalAndExpression_DropletFileContext.prototype.constructor = LogicalAndExpression_DropletFileContext;

LogicalAndExpression_DropletFileContext.prototype.inclusiveOrExpression = function() {
    return this.getTypedRuleContext(InclusiveOrExpressionContext,0);
};

LogicalAndExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

LogicalAndExpression_DropletFileContext.prototype.logicalAndExpression = function() {
    return this.getTypedRuleContext(LogicalAndExpressionContext,0);
};

LogicalAndExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterLogicalAndExpression_DropletFile(this);
	}
};

LogicalAndExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitLogicalAndExpression_DropletFile(this);
	}
};




CParser.LogicalAndExpression_DropletFileContext = LogicalAndExpression_DropletFileContext;

CParser.prototype.logicalAndExpression_DropletFile = function() {

    var localctx = new LogicalAndExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 206, CParser.RULE_logicalAndExpression_DropletFile);
    try {
        this.state = 1787;
        var la_ = this._interp.adaptivePredict(this._input,158,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1779;
            this.inclusiveOrExpression(0);
            this.state = 1780;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1782;
            this.logicalAndExpression(0);
            this.state = 1783;
            this.match(CParser.AndAnd);
            this.state = 1784;
            this.inclusiveOrExpression(0);
            this.state = 1785;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function LogicalOrExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_logicalOrExpression_DropletFile;
    return this;
}

LogicalOrExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
LogicalOrExpression_DropletFileContext.prototype.constructor = LogicalOrExpression_DropletFileContext;

LogicalOrExpression_DropletFileContext.prototype.logicalAndExpression = function() {
    return this.getTypedRuleContext(LogicalAndExpressionContext,0);
};

LogicalOrExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

LogicalOrExpression_DropletFileContext.prototype.logicalOrExpression = function() {
    return this.getTypedRuleContext(LogicalOrExpressionContext,0);
};

LogicalOrExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterLogicalOrExpression_DropletFile(this);
	}
};

LogicalOrExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitLogicalOrExpression_DropletFile(this);
	}
};




CParser.LogicalOrExpression_DropletFileContext = LogicalOrExpression_DropletFileContext;

CParser.prototype.logicalOrExpression_DropletFile = function() {

    var localctx = new LogicalOrExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 208, CParser.RULE_logicalOrExpression_DropletFile);
    try {
        this.state = 1797;
        var la_ = this._interp.adaptivePredict(this._input,159,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1789;
            this.logicalAndExpression(0);
            this.state = 1790;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1792;
            this.logicalOrExpression(0);
            this.state = 1793;
            this.match(CParser.OrOr);
            this.state = 1794;
            this.logicalAndExpression(0);
            this.state = 1795;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ConditionalExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_conditionalExpression_DropletFile;
    return this;
}

ConditionalExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ConditionalExpression_DropletFileContext.prototype.constructor = ConditionalExpression_DropletFileContext;

ConditionalExpression_DropletFileContext.prototype.logicalOrExpression = function() {
    return this.getTypedRuleContext(LogicalOrExpressionContext,0);
};

ConditionalExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ConditionalExpression_DropletFileContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

ConditionalExpression_DropletFileContext.prototype.conditionalExpression = function() {
    return this.getTypedRuleContext(ConditionalExpressionContext,0);
};

ConditionalExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterConditionalExpression_DropletFile(this);
	}
};

ConditionalExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitConditionalExpression_DropletFile(this);
	}
};




CParser.ConditionalExpression_DropletFileContext = ConditionalExpression_DropletFileContext;

CParser.prototype.conditionalExpression_DropletFile = function() {

    var localctx = new ConditionalExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 210, CParser.RULE_conditionalExpression_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1799;
        this.logicalOrExpression(0);
        this.state = 1805;
        _la = this._input.LA(1);
        if(_la===CParser.Question) {
            this.state = 1800;
            this.match(CParser.Question);
            this.state = 1801;
            this.expression(0);
            this.state = 1802;
            this.match(CParser.Colon);
            this.state = 1803;
            this.conditionalExpression();
        }

        this.state = 1807;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AssignmentExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_assignmentExpression_DropletFile;
    return this;
}

AssignmentExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AssignmentExpression_DropletFileContext.prototype.constructor = AssignmentExpression_DropletFileContext;

AssignmentExpression_DropletFileContext.prototype.conditionalExpression = function() {
    return this.getTypedRuleContext(ConditionalExpressionContext,0);
};

AssignmentExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

AssignmentExpression_DropletFileContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

AssignmentExpression_DropletFileContext.prototype.assignmentOperator = function() {
    return this.getTypedRuleContext(AssignmentOperatorContext,0);
};

AssignmentExpression_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

AssignmentExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAssignmentExpression_DropletFile(this);
	}
};

AssignmentExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAssignmentExpression_DropletFile(this);
	}
};




CParser.AssignmentExpression_DropletFileContext = AssignmentExpression_DropletFileContext;

CParser.prototype.assignmentExpression_DropletFile = function() {

    var localctx = new AssignmentExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 212, CParser.RULE_assignmentExpression_DropletFile);
    try {
        this.state = 1817;
        var la_ = this._interp.adaptivePredict(this._input,161,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1809;
            this.conditionalExpression();
            this.state = 1810;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1812;
            this.unaryExpression();
            this.state = 1813;
            this.assignmentOperator();
            this.state = 1814;
            this.assignmentExpression();
            this.state = 1815;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AssignmentOperator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_assignmentOperator_DropletFile;
    return this;
}

AssignmentOperator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AssignmentOperator_DropletFileContext.prototype.constructor = AssignmentOperator_DropletFileContext;

AssignmentOperator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

AssignmentOperator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAssignmentOperator_DropletFile(this);
	}
};

AssignmentOperator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAssignmentOperator_DropletFile(this);
	}
};




CParser.AssignmentOperator_DropletFileContext = AssignmentOperator_DropletFileContext;

CParser.prototype.assignmentOperator_DropletFile = function() {

    var localctx = new AssignmentOperator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 214, CParser.RULE_assignmentOperator_DropletFile);
    try {
        this.state = 1831;
        switch(this._input.LA(1)) {
        case CParser.Assign:
            this.enterOuterAlt(localctx, 1);
            this.state = 1819;
            this.match(CParser.Assign);
            break;
        case CParser.StarAssign:
            this.enterOuterAlt(localctx, 2);
            this.state = 1820;
            this.match(CParser.StarAssign);
            break;
        case CParser.DivAssign:
            this.enterOuterAlt(localctx, 3);
            this.state = 1821;
            this.match(CParser.DivAssign);
            break;
        case CParser.ModAssign:
            this.enterOuterAlt(localctx, 4);
            this.state = 1822;
            this.match(CParser.ModAssign);
            break;
        case CParser.PlusAssign:
            this.enterOuterAlt(localctx, 5);
            this.state = 1823;
            this.match(CParser.PlusAssign);
            break;
        case CParser.MinusAssign:
            this.enterOuterAlt(localctx, 6);
            this.state = 1824;
            this.match(CParser.MinusAssign);
            break;
        case CParser.LeftShiftAssign:
            this.enterOuterAlt(localctx, 7);
            this.state = 1825;
            this.match(CParser.LeftShiftAssign);
            break;
        case CParser.RightShiftAssign:
            this.enterOuterAlt(localctx, 8);
            this.state = 1826;
            this.match(CParser.RightShiftAssign);
            break;
        case CParser.AndAssign:
            this.enterOuterAlt(localctx, 9);
            this.state = 1827;
            this.match(CParser.AndAssign);
            break;
        case CParser.XorAssign:
            this.enterOuterAlt(localctx, 10);
            this.state = 1828;
            this.match(CParser.XorAssign);
            break;
        case CParser.OrAssign:
            this.enterOuterAlt(localctx, 11);
            this.state = 1829;
            this.match(CParser.OrAssign);
            this.state = 1830;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Expression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_expression_DropletFile;
    return this;
}

Expression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Expression_DropletFileContext.prototype.constructor = Expression_DropletFileContext;

Expression_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

Expression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Expression_DropletFileContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

Expression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExpression_DropletFile(this);
	}
};

Expression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExpression_DropletFile(this);
	}
};




CParser.Expression_DropletFileContext = Expression_DropletFileContext;

CParser.prototype.expression_DropletFile = function() {

    var localctx = new Expression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 216, CParser.RULE_expression_DropletFile);
    try {
        this.state = 1841;
        var la_ = this._interp.adaptivePredict(this._input,163,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1833;
            this.assignmentExpression();
            this.state = 1834;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1836;
            this.expression(0);
            this.state = 1837;
            this.match(CParser.Comma);
            this.state = 1838;
            this.assignmentExpression();
            this.state = 1839;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ConstantExpression_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_constantExpression_DropletFile;
    return this;
}

ConstantExpression_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ConstantExpression_DropletFileContext.prototype.constructor = ConstantExpression_DropletFileContext;

ConstantExpression_DropletFileContext.prototype.conditionalExpression = function() {
    return this.getTypedRuleContext(ConditionalExpressionContext,0);
};

ConstantExpression_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ConstantExpression_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterConstantExpression_DropletFile(this);
	}
};

ConstantExpression_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitConstantExpression_DropletFile(this);
	}
};




CParser.ConstantExpression_DropletFileContext = ConstantExpression_DropletFileContext;

CParser.prototype.constantExpression_DropletFile = function() {

    var localctx = new ConstantExpression_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 218, CParser.RULE_constantExpression_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1843;
        this.conditionalExpression();
        this.state = 1844;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Declaration_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declaration_DropletFile;
    return this;
}

Declaration_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Declaration_DropletFileContext.prototype.constructor = Declaration_DropletFileContext;

Declaration_DropletFileContext.prototype.declarationSpecifiers = function() {
    return this.getTypedRuleContext(DeclarationSpecifiersContext,0);
};

Declaration_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Declaration_DropletFileContext.prototype.initDeclaratorList = function() {
    return this.getTypedRuleContext(InitDeclaratorListContext,0);
};

Declaration_DropletFileContext.prototype.staticAssertDeclaration = function() {
    return this.getTypedRuleContext(StaticAssertDeclarationContext,0);
};

Declaration_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclaration_DropletFile(this);
	}
};

Declaration_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclaration_DropletFile(this);
	}
};




CParser.Declaration_DropletFileContext = Declaration_DropletFileContext;

CParser.prototype.declaration_DropletFile = function() {

    var localctx = new Declaration_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 220, CParser.RULE_declaration_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 1856;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.T__7:
        case CParser.T__8:
        case CParser.T__9:
        case CParser.T__11:
        case CParser.Auto:
        case CParser.Char:
        case CParser.Const:
        case CParser.Double:
        case CParser.Enum:
        case CParser.Extern:
        case CParser.Float:
        case CParser.Inline:
        case CParser.Int:
        case CParser.Long:
        case CParser.Register:
        case CParser.Restrict:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Static:
        case CParser.Struct:
        case CParser.Typedef:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.Alignas:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Noreturn:
        case CParser.ThreadLocal:
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 1846;
            this.declarationSpecifiers();
            this.state = 1848;
            _la = this._input.LA(1);
            if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) !== 0) || _la===CParser.Identifier) {
                this.state = 1847;
                this.initDeclaratorList(0);
            }

            this.state = 1850;
            this.match(CParser.Semi);
            this.state = 1851;
            this.match(CParser.EOF);
            break;
        case CParser.StaticAssert:
            this.enterOuterAlt(localctx, 2);
            this.state = 1853;
            this.staticAssertDeclaration();
            this.state = 1854;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationSpecifiers_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationSpecifiers_DropletFile;
    return this;
}

DeclarationSpecifiers_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationSpecifiers_DropletFileContext.prototype.constructor = DeclarationSpecifiers_DropletFileContext;

DeclarationSpecifiers_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

DeclarationSpecifiers_DropletFileContext.prototype.declarationSpecifier = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(DeclarationSpecifierContext);
    } else {
        return this.getTypedRuleContext(DeclarationSpecifierContext,i);
    }
};

DeclarationSpecifiers_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationSpecifiers_DropletFile(this);
	}
};

DeclarationSpecifiers_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationSpecifiers_DropletFile(this);
	}
};




CParser.DeclarationSpecifiers_DropletFileContext = DeclarationSpecifiers_DropletFileContext;

CParser.prototype.declarationSpecifiers_DropletFile = function() {

    var localctx = new DeclarationSpecifiers_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 222, CParser.RULE_declarationSpecifiers_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1859; 
        this._errHandler.sync(this);
        _la = this._input.LA(1);
        do {
            this.state = 1858;
            this.declarationSpecifier();
            this.state = 1861; 
            this._errHandler.sync(this);
            _la = this._input.LA(1);
        } while((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier);
        this.state = 1863;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationSpecifiers2_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationSpecifiers2_DropletFile;
    return this;
}

DeclarationSpecifiers2_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationSpecifiers2_DropletFileContext.prototype.constructor = DeclarationSpecifiers2_DropletFileContext;

DeclarationSpecifiers2_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

DeclarationSpecifiers2_DropletFileContext.prototype.declarationSpecifier = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(DeclarationSpecifierContext);
    } else {
        return this.getTypedRuleContext(DeclarationSpecifierContext,i);
    }
};

DeclarationSpecifiers2_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationSpecifiers2_DropletFile(this);
	}
};

DeclarationSpecifiers2_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationSpecifiers2_DropletFile(this);
	}
};




CParser.DeclarationSpecifiers2_DropletFileContext = DeclarationSpecifiers2_DropletFileContext;

CParser.prototype.declarationSpecifiers2_DropletFile = function() {

    var localctx = new DeclarationSpecifiers2_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 224, CParser.RULE_declarationSpecifiers2_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1866; 
        this._errHandler.sync(this);
        _la = this._input.LA(1);
        do {
            this.state = 1865;
            this.declarationSpecifier();
            this.state = 1868; 
            this._errHandler.sync(this);
            _la = this._input.LA(1);
        } while((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier);
        this.state = 1870;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationSpecifier_DropletFile;
    return this;
}

DeclarationSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationSpecifier_DropletFileContext.prototype.constructor = DeclarationSpecifier_DropletFileContext;

DeclarationSpecifier_DropletFileContext.prototype.storageClassSpecifier = function() {
    return this.getTypedRuleContext(StorageClassSpecifierContext,0);
};

DeclarationSpecifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

DeclarationSpecifier_DropletFileContext.prototype.typeSpecifier = function() {
    return this.getTypedRuleContext(TypeSpecifierContext,0);
};

DeclarationSpecifier_DropletFileContext.prototype.typeQualifier = function() {
    return this.getTypedRuleContext(TypeQualifierContext,0);
};

DeclarationSpecifier_DropletFileContext.prototype.functionSpecifier = function() {
    return this.getTypedRuleContext(FunctionSpecifierContext,0);
};

DeclarationSpecifier_DropletFileContext.prototype.alignmentSpecifier = function() {
    return this.getTypedRuleContext(AlignmentSpecifierContext,0);
};

DeclarationSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationSpecifier_DropletFile(this);
	}
};

DeclarationSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationSpecifier_DropletFile(this);
	}
};




CParser.DeclarationSpecifier_DropletFileContext = DeclarationSpecifier_DropletFileContext;

CParser.prototype.declarationSpecifier_DropletFile = function() {

    var localctx = new DeclarationSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 226, CParser.RULE_declarationSpecifier_DropletFile);
    try {
        this.state = 1887;
        var la_ = this._interp.adaptivePredict(this._input,168,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1872;
            this.storageClassSpecifier();
            this.state = 1873;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1875;
            this.typeSpecifier();
            this.state = 1876;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 1878;
            this.typeQualifier();
            this.state = 1879;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 1881;
            this.functionSpecifier();
            this.state = 1882;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 1884;
            this.alignmentSpecifier();
            this.state = 1885;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function InitDeclaratorList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initDeclaratorList_DropletFile;
    return this;
}

InitDeclaratorList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InitDeclaratorList_DropletFileContext.prototype.constructor = InitDeclaratorList_DropletFileContext;

InitDeclaratorList_DropletFileContext.prototype.initDeclarator = function() {
    return this.getTypedRuleContext(InitDeclaratorContext,0);
};

InitDeclaratorList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

InitDeclaratorList_DropletFileContext.prototype.initDeclaratorList = function() {
    return this.getTypedRuleContext(InitDeclaratorListContext,0);
};

InitDeclaratorList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitDeclaratorList_DropletFile(this);
	}
};

InitDeclaratorList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitDeclaratorList_DropletFile(this);
	}
};




CParser.InitDeclaratorList_DropletFileContext = InitDeclaratorList_DropletFileContext;

CParser.prototype.initDeclaratorList_DropletFile = function() {

    var localctx = new InitDeclaratorList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 228, CParser.RULE_initDeclaratorList_DropletFile);
    try {
        this.state = 1897;
        var la_ = this._interp.adaptivePredict(this._input,169,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1889;
            this.initDeclarator();
            this.state = 1890;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1892;
            this.initDeclaratorList(0);
            this.state = 1893;
            this.match(CParser.Comma);
            this.state = 1894;
            this.initDeclarator();
            this.state = 1895;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function InitDeclarator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initDeclarator_DropletFile;
    return this;
}

InitDeclarator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InitDeclarator_DropletFileContext.prototype.constructor = InitDeclarator_DropletFileContext;

InitDeclarator_DropletFileContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

InitDeclarator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

InitDeclarator_DropletFileContext.prototype.initializer = function() {
    return this.getTypedRuleContext(InitializerContext,0);
};

InitDeclarator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitDeclarator_DropletFile(this);
	}
};

InitDeclarator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitDeclarator_DropletFile(this);
	}
};




CParser.InitDeclarator_DropletFileContext = InitDeclarator_DropletFileContext;

CParser.prototype.initDeclarator_DropletFile = function() {

    var localctx = new InitDeclarator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 230, CParser.RULE_initDeclarator_DropletFile);
    try {
        this.state = 1907;
        var la_ = this._interp.adaptivePredict(this._input,170,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1899;
            this.declarator();
            this.state = 1900;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1902;
            this.declarator();
            this.state = 1903;
            this.match(CParser.Assign);
            this.state = 1904;
            this.initializer();
            this.state = 1905;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StorageClassSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_storageClassSpecifier_DropletFile;
    return this;
}

StorageClassSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StorageClassSpecifier_DropletFileContext.prototype.constructor = StorageClassSpecifier_DropletFileContext;

StorageClassSpecifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StorageClassSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStorageClassSpecifier_DropletFile(this);
	}
};

StorageClassSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStorageClassSpecifier_DropletFile(this);
	}
};




CParser.StorageClassSpecifier_DropletFileContext = StorageClassSpecifier_DropletFileContext;

CParser.prototype.storageClassSpecifier_DropletFile = function() {

    var localctx = new StorageClassSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 232, CParser.RULE_storageClassSpecifier_DropletFile);
    try {
        this.state = 1921;
        switch(this._input.LA(1)) {
        case CParser.Typedef:
            this.enterOuterAlt(localctx, 1);
            this.state = 1909;
            this.match(CParser.Typedef);
            this.state = 1910;
            this.match(CParser.EOF);
            break;
        case CParser.Extern:
            this.enterOuterAlt(localctx, 2);
            this.state = 1911;
            this.match(CParser.Extern);
            this.state = 1912;
            this.match(CParser.EOF);
            break;
        case CParser.Static:
            this.enterOuterAlt(localctx, 3);
            this.state = 1913;
            this.match(CParser.Static);
            this.state = 1914;
            this.match(CParser.EOF);
            break;
        case CParser.ThreadLocal:
            this.enterOuterAlt(localctx, 4);
            this.state = 1915;
            this.match(CParser.ThreadLocal);
            this.state = 1916;
            this.match(CParser.EOF);
            break;
        case CParser.Auto:
            this.enterOuterAlt(localctx, 5);
            this.state = 1917;
            this.match(CParser.Auto);
            this.state = 1918;
            this.match(CParser.EOF);
            break;
        case CParser.Register:
            this.enterOuterAlt(localctx, 6);
            this.state = 1919;
            this.match(CParser.Register);
            this.state = 1920;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypeSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeSpecifier_DropletFile;
    return this;
}

TypeSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeSpecifier_DropletFileContext.prototype.constructor = TypeSpecifier_DropletFileContext;

TypeSpecifier_DropletFileContext.prototype.EOF = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.EOF);
    } else {
        return this.getToken(CParser.EOF, i);
    }
};


TypeSpecifier_DropletFileContext.prototype.atomicTypeSpecifier = function() {
    return this.getTypedRuleContext(AtomicTypeSpecifierContext,0);
};

TypeSpecifier_DropletFileContext.prototype.structOrUnionSpecifier = function() {
    return this.getTypedRuleContext(StructOrUnionSpecifierContext,0);
};

TypeSpecifier_DropletFileContext.prototype.enumSpecifier = function() {
    return this.getTypedRuleContext(EnumSpecifierContext,0);
};

TypeSpecifier_DropletFileContext.prototype.typedefName = function() {
    return this.getTypedRuleContext(TypedefNameContext,0);
};

TypeSpecifier_DropletFileContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

TypeSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeSpecifier_DropletFile(this);
	}
};

TypeSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeSpecifier_DropletFile(this);
	}
};




CParser.TypeSpecifier_DropletFileContext = TypeSpecifier_DropletFileContext;

CParser.prototype.typeSpecifier_DropletFile = function() {

    var localctx = new TypeSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 234, CParser.RULE_typeSpecifier_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 1975;
        switch(this._input.LA(1)) {
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.Char:
        case CParser.Double:
        case CParser.Float:
        case CParser.Int:
        case CParser.Long:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Bool:
        case CParser.Complex:
            this.enterOuterAlt(localctx, 1);
            this.state = 1950;
            switch(this._input.LA(1)) {
            case CParser.Void:
                this.state = 1923;
                this.match(CParser.Void);
                this.state = 1924;
                this.match(CParser.EOF);
                break;
            case CParser.Char:
                this.state = 1925;
                this.match(CParser.Char);
                this.state = 1926;
                this.match(CParser.EOF);
                break;
            case CParser.Short:
                this.state = 1927;
                this.match(CParser.Short);
                this.state = 1928;
                this.match(CParser.EOF);
                break;
            case CParser.Int:
                this.state = 1929;
                this.match(CParser.Int);
                this.state = 1930;
                this.match(CParser.EOF);
                break;
            case CParser.Long:
                this.state = 1931;
                this.match(CParser.Long);
                this.state = 1932;
                this.match(CParser.EOF);
                break;
            case CParser.Float:
                this.state = 1933;
                this.match(CParser.Float);
                this.state = 1934;
                this.match(CParser.EOF);
                break;
            case CParser.Double:
                this.state = 1935;
                this.match(CParser.Double);
                this.state = 1936;
                this.match(CParser.EOF);
                break;
            case CParser.Signed:
                this.state = 1937;
                this.match(CParser.Signed);
                this.state = 1938;
                this.match(CParser.EOF);
                break;
            case CParser.Unsigned:
                this.state = 1939;
                this.match(CParser.Unsigned);
                this.state = 1940;
                this.match(CParser.EOF);
                break;
            case CParser.Bool:
                this.state = 1941;
                this.match(CParser.Bool);
                this.state = 1942;
                this.match(CParser.EOF);
                break;
            case CParser.Complex:
                this.state = 1943;
                this.match(CParser.Complex);
                this.state = 1944;
                this.match(CParser.EOF);
                break;
            case CParser.T__3:
                this.state = 1945;
                this.match(CParser.T__3);
                this.state = 1946;
                this.match(CParser.EOF);
                break;
            case CParser.T__4:
                this.state = 1947;
                this.match(CParser.T__4);
                this.state = 1948;
                this.match(CParser.EOF);
                break;
            case CParser.T__5:
                this.state = 1949;
                this.match(CParser.T__5);
                break;
            default:
                throw new antlr4.error.NoViableAltException(this);
            }
            this.state = 1952;
            this.match(CParser.EOF);
            break;
        case CParser.T__0:
            this.enterOuterAlt(localctx, 2);
            this.state = 1953;
            this.match(CParser.T__0);
            this.state = 1954;
            this.match(CParser.LeftParen);
            this.state = 1955;
            _la = this._input.LA(1);
            if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5))) !== 0))) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 1956;
            this.match(CParser.RightParen);
            this.state = 1957;
            this.match(CParser.EOF);
            break;
        case CParser.Atomic:
            this.enterOuterAlt(localctx, 3);
            this.state = 1958;
            this.atomicTypeSpecifier();
            this.state = 1959;
            this.match(CParser.EOF);
            break;
        case CParser.Struct:
        case CParser.Union:
            this.enterOuterAlt(localctx, 4);
            this.state = 1961;
            this.structOrUnionSpecifier();
            this.state = 1962;
            this.match(CParser.EOF);
            break;
        case CParser.Enum:
            this.enterOuterAlt(localctx, 5);
            this.state = 1964;
            this.enumSpecifier();
            this.state = 1965;
            this.match(CParser.EOF);
            break;
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 6);
            this.state = 1967;
            this.typedefName();
            this.state = 1968;
            this.match(CParser.EOF);
            break;
        case CParser.T__6:
            this.enterOuterAlt(localctx, 7);
            this.state = 1970;
            this.match(CParser.T__6);
            this.state = 1971;
            this.match(CParser.LeftParen);
            this.state = 1972;
            this.constantExpression();
            this.state = 1973;
            this.match(CParser.RightParen);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructOrUnionSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structOrUnionSpecifier_DropletFile;
    return this;
}

StructOrUnionSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructOrUnionSpecifier_DropletFileContext.prototype.constructor = StructOrUnionSpecifier_DropletFileContext;

StructOrUnionSpecifier_DropletFileContext.prototype.structOrUnion = function() {
    return this.getTypedRuleContext(StructOrUnionContext,0);
};

StructOrUnionSpecifier_DropletFileContext.prototype.structDeclarationsBlock = function() {
    return this.getTypedRuleContext(StructDeclarationsBlockContext,0);
};

StructOrUnionSpecifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StructOrUnionSpecifier_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

StructOrUnionSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructOrUnionSpecifier_DropletFile(this);
	}
};

StructOrUnionSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructOrUnionSpecifier_DropletFile(this);
	}
};




CParser.StructOrUnionSpecifier_DropletFileContext = StructOrUnionSpecifier_DropletFileContext;

CParser.prototype.structOrUnionSpecifier_DropletFile = function() {

    var localctx = new StructOrUnionSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 236, CParser.RULE_structOrUnionSpecifier_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 1988;
        var la_ = this._interp.adaptivePredict(this._input,175,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 1977;
            this.structOrUnion();
            this.state = 1979;
            _la = this._input.LA(1);
            if(_la===CParser.Identifier) {
                this.state = 1978;
                this.match(CParser.Identifier);
            }

            this.state = 1981;
            this.structDeclarationsBlock();
            this.state = 1982;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 1984;
            this.structOrUnion();
            this.state = 1985;
            this.match(CParser.Identifier);
            this.state = 1986;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructOrUnion_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structOrUnion_DropletFile;
    return this;
}

StructOrUnion_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructOrUnion_DropletFileContext.prototype.constructor = StructOrUnion_DropletFileContext;

StructOrUnion_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StructOrUnion_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructOrUnion_DropletFile(this);
	}
};

StructOrUnion_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructOrUnion_DropletFile(this);
	}
};




CParser.StructOrUnion_DropletFileContext = StructOrUnion_DropletFileContext;

CParser.prototype.structOrUnion_DropletFile = function() {

    var localctx = new StructOrUnion_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 238, CParser.RULE_structOrUnion_DropletFile);
    try {
        this.state = 1994;
        switch(this._input.LA(1)) {
        case CParser.Struct:
            this.enterOuterAlt(localctx, 1);
            this.state = 1990;
            this.match(CParser.Struct);
            this.state = 1991;
            this.match(CParser.EOF);
            break;
        case CParser.Union:
            this.enterOuterAlt(localctx, 2);
            this.state = 1992;
            this.match(CParser.Union);
            this.state = 1993;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclarationsBlock_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclarationsBlock_DropletFile;
    return this;
}

StructDeclarationsBlock_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclarationsBlock_DropletFileContext.prototype.constructor = StructDeclarationsBlock_DropletFileContext;

StructDeclarationsBlock_DropletFileContext.prototype.structDeclarationList = function() {
    return this.getTypedRuleContext(StructDeclarationListContext,0);
};

StructDeclarationsBlock_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StructDeclarationsBlock_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclarationsBlock_DropletFile(this);
	}
};

StructDeclarationsBlock_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclarationsBlock_DropletFile(this);
	}
};




CParser.StructDeclarationsBlock_DropletFileContext = StructDeclarationsBlock_DropletFileContext;

CParser.prototype.structDeclarationsBlock_DropletFile = function() {

    var localctx = new StructDeclarationsBlock_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 240, CParser.RULE_structDeclarationsBlock_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 1996;
        this.match(CParser.LeftBrace);
        this.state = 1997;
        this.structDeclarationList(0);
        this.state = 1998;
        this.match(CParser.RightBrace);
        this.state = 1999;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclarationList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclarationList_DropletFile;
    return this;
}

StructDeclarationList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclarationList_DropletFileContext.prototype.constructor = StructDeclarationList_DropletFileContext;

StructDeclarationList_DropletFileContext.prototype.structDeclaration = function() {
    return this.getTypedRuleContext(StructDeclarationContext,0);
};

StructDeclarationList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StructDeclarationList_DropletFileContext.prototype.structDeclarationList = function() {
    return this.getTypedRuleContext(StructDeclarationListContext,0);
};

StructDeclarationList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclarationList_DropletFile(this);
	}
};

StructDeclarationList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclarationList_DropletFile(this);
	}
};




CParser.StructDeclarationList_DropletFileContext = StructDeclarationList_DropletFileContext;

CParser.prototype.structDeclarationList_DropletFile = function() {

    var localctx = new StructDeclarationList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 242, CParser.RULE_structDeclarationList_DropletFile);
    try {
        this.state = 2008;
        var la_ = this._interp.adaptivePredict(this._input,177,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2001;
            this.structDeclaration();
            this.state = 2002;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2004;
            this.structDeclarationList(0);
            this.state = 2005;
            this.structDeclaration();
            this.state = 2006;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclaration_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclaration_DropletFile;
    return this;
}

StructDeclaration_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclaration_DropletFileContext.prototype.constructor = StructDeclaration_DropletFileContext;

StructDeclaration_DropletFileContext.prototype.specifierQualifierList = function() {
    return this.getTypedRuleContext(SpecifierQualifierListContext,0);
};

StructDeclaration_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StructDeclaration_DropletFileContext.prototype.structDeclaratorList = function() {
    return this.getTypedRuleContext(StructDeclaratorListContext,0);
};

StructDeclaration_DropletFileContext.prototype.staticAssertDeclaration = function() {
    return this.getTypedRuleContext(StaticAssertDeclarationContext,0);
};

StructDeclaration_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclaration_DropletFile(this);
	}
};

StructDeclaration_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclaration_DropletFile(this);
	}
};




CParser.StructDeclaration_DropletFileContext = StructDeclaration_DropletFileContext;

CParser.prototype.structDeclaration_DropletFile = function() {

    var localctx = new StructDeclaration_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 244, CParser.RULE_structDeclaration_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2020;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.Char:
        case CParser.Const:
        case CParser.Double:
        case CParser.Enum:
        case CParser.Float:
        case CParser.Int:
        case CParser.Long:
        case CParser.Restrict:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Struct:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 2010;
            this.specifierQualifierList();
            this.state = 2012;
            _la = this._input.LA(1);
            if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)) | (1 << (CParser.Colon - 59)))) !== 0) || _la===CParser.Identifier) {
                this.state = 2011;
                this.structDeclaratorList(0);
            }

            this.state = 2014;
            this.match(CParser.Semi);
            this.state = 2015;
            this.match(CParser.EOF);
            break;
        case CParser.StaticAssert:
            this.enterOuterAlt(localctx, 2);
            this.state = 2017;
            this.staticAssertDeclaration();
            this.state = 2018;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function SpecifierQualifierList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_specifierQualifierList_DropletFile;
    return this;
}

SpecifierQualifierList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
SpecifierQualifierList_DropletFileContext.prototype.constructor = SpecifierQualifierList_DropletFileContext;

SpecifierQualifierList_DropletFileContext.prototype.typeSpecifier = function() {
    return this.getTypedRuleContext(TypeSpecifierContext,0);
};

SpecifierQualifierList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

SpecifierQualifierList_DropletFileContext.prototype.specifierQualifierList = function() {
    return this.getTypedRuleContext(SpecifierQualifierListContext,0);
};

SpecifierQualifierList_DropletFileContext.prototype.typeQualifier = function() {
    return this.getTypedRuleContext(TypeQualifierContext,0);
};

SpecifierQualifierList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterSpecifierQualifierList_DropletFile(this);
	}
};

SpecifierQualifierList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitSpecifierQualifierList_DropletFile(this);
	}
};




CParser.SpecifierQualifierList_DropletFileContext = SpecifierQualifierList_DropletFileContext;

CParser.prototype.specifierQualifierList_DropletFile = function() {

    var localctx = new SpecifierQualifierList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 246, CParser.RULE_specifierQualifierList_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2034;
        var la_ = this._interp.adaptivePredict(this._input,182,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2022;
            this.typeSpecifier();
            this.state = 2024;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Float))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)))) !== 0) || _la===CParser.Identifier) {
                this.state = 2023;
                this.specifierQualifierList();
            }

            this.state = 2026;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2028;
            this.typeQualifier();
            this.state = 2030;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Float))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)))) !== 0) || _la===CParser.Identifier) {
                this.state = 2029;
                this.specifierQualifierList();
            }

            this.state = 2032;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclaratorList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclaratorList_DropletFile;
    return this;
}

StructDeclaratorList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclaratorList_DropletFileContext.prototype.constructor = StructDeclaratorList_DropletFileContext;

StructDeclaratorList_DropletFileContext.prototype.structDeclarator = function() {
    return this.getTypedRuleContext(StructDeclaratorContext,0);
};

StructDeclaratorList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StructDeclaratorList_DropletFileContext.prototype.structDeclaratorList = function() {
    return this.getTypedRuleContext(StructDeclaratorListContext,0);
};

StructDeclaratorList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclaratorList_DropletFile(this);
	}
};

StructDeclaratorList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclaratorList_DropletFile(this);
	}
};




CParser.StructDeclaratorList_DropletFileContext = StructDeclaratorList_DropletFileContext;

CParser.prototype.structDeclaratorList_DropletFile = function() {

    var localctx = new StructDeclaratorList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 248, CParser.RULE_structDeclaratorList_DropletFile);
    try {
        this.state = 2044;
        var la_ = this._interp.adaptivePredict(this._input,183,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2036;
            this.structDeclarator();
            this.state = 2037;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2039;
            this.structDeclaratorList(0);
            this.state = 2040;
            this.match(CParser.Comma);
            this.state = 2041;
            this.structDeclarator();
            this.state = 2042;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StructDeclarator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_structDeclarator_DropletFile;
    return this;
}

StructDeclarator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StructDeclarator_DropletFileContext.prototype.constructor = StructDeclarator_DropletFileContext;

StructDeclarator_DropletFileContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

StructDeclarator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StructDeclarator_DropletFileContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

StructDeclarator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStructDeclarator_DropletFile(this);
	}
};

StructDeclarator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStructDeclarator_DropletFile(this);
	}
};




CParser.StructDeclarator_DropletFileContext = StructDeclarator_DropletFileContext;

CParser.prototype.structDeclarator_DropletFile = function() {

    var localctx = new StructDeclarator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 250, CParser.RULE_structDeclarator_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2056;
        var la_ = this._interp.adaptivePredict(this._input,185,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2046;
            this.declarator();
            this.state = 2047;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2050;
            _la = this._input.LA(1);
            if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) !== 0) || _la===CParser.Identifier) {
                this.state = 2049;
                this.declarator();
            }

            this.state = 2052;
            this.match(CParser.Colon);
            this.state = 2053;
            this.constantExpression();
            this.state = 2054;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function EnumSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumSpecifier_DropletFile;
    return this;
}

EnumSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EnumSpecifier_DropletFileContext.prototype.constructor = EnumSpecifier_DropletFileContext;

EnumSpecifier_DropletFileContext.prototype.enumeratorList = function() {
    return this.getTypedRuleContext(EnumeratorListContext,0);
};

EnumSpecifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

EnumSpecifier_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

EnumSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumSpecifier_DropletFile(this);
	}
};

EnumSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumSpecifier_DropletFile(this);
	}
};




CParser.EnumSpecifier_DropletFileContext = EnumSpecifier_DropletFileContext;

CParser.prototype.enumSpecifier_DropletFile = function() {

    var localctx = new EnumSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 252, CParser.RULE_enumSpecifier_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2080;
        var la_ = this._interp.adaptivePredict(this._input,188,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2058;
            this.match(CParser.Enum);
            this.state = 2060;
            _la = this._input.LA(1);
            if(_la===CParser.Identifier) {
                this.state = 2059;
                this.match(CParser.Identifier);
            }

            this.state = 2062;
            this.match(CParser.LeftBrace);
            this.state = 2063;
            this.enumeratorList(0);
            this.state = 2064;
            this.match(CParser.RightBrace);
            this.state = 2065;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2067;
            this.match(CParser.Enum);
            this.state = 2069;
            _la = this._input.LA(1);
            if(_la===CParser.Identifier) {
                this.state = 2068;
                this.match(CParser.Identifier);
            }

            this.state = 2071;
            this.match(CParser.LeftBrace);
            this.state = 2072;
            this.enumeratorList(0);
            this.state = 2073;
            this.match(CParser.Comma);
            this.state = 2074;
            this.match(CParser.RightBrace);
            this.state = 2075;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2077;
            this.match(CParser.Enum);
            this.state = 2078;
            this.match(CParser.Identifier);
            this.state = 2079;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function EnumeratorList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumeratorList_DropletFile;
    return this;
}

EnumeratorList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EnumeratorList_DropletFileContext.prototype.constructor = EnumeratorList_DropletFileContext;

EnumeratorList_DropletFileContext.prototype.enumerator = function() {
    return this.getTypedRuleContext(EnumeratorContext,0);
};

EnumeratorList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

EnumeratorList_DropletFileContext.prototype.enumeratorList = function() {
    return this.getTypedRuleContext(EnumeratorListContext,0);
};

EnumeratorList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumeratorList_DropletFile(this);
	}
};

EnumeratorList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumeratorList_DropletFile(this);
	}
};




CParser.EnumeratorList_DropletFileContext = EnumeratorList_DropletFileContext;

CParser.prototype.enumeratorList_DropletFile = function() {

    var localctx = new EnumeratorList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 254, CParser.RULE_enumeratorList_DropletFile);
    try {
        this.state = 2090;
        var la_ = this._interp.adaptivePredict(this._input,189,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2082;
            this.enumerator();
            this.state = 2083;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2085;
            this.enumeratorList(0);
            this.state = 2086;
            this.match(CParser.Comma);
            this.state = 2087;
            this.enumerator();
            this.state = 2088;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Enumerator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumerator_DropletFile;
    return this;
}

Enumerator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Enumerator_DropletFileContext.prototype.constructor = Enumerator_DropletFileContext;

Enumerator_DropletFileContext.prototype.enumerationConstant = function() {
    return this.getTypedRuleContext(EnumerationConstantContext,0);
};

Enumerator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Enumerator_DropletFileContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

Enumerator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumerator_DropletFile(this);
	}
};

Enumerator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumerator_DropletFile(this);
	}
};




CParser.Enumerator_DropletFileContext = Enumerator_DropletFileContext;

CParser.prototype.enumerator_DropletFile = function() {

    var localctx = new Enumerator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 256, CParser.RULE_enumerator_DropletFile);
    try {
        this.state = 2100;
        var la_ = this._interp.adaptivePredict(this._input,190,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2092;
            this.enumerationConstant();
            this.state = 2093;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2095;
            this.enumerationConstant();
            this.state = 2096;
            this.match(CParser.Assign);
            this.state = 2097;
            this.constantExpression();
            this.state = 2098;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function EnumerationConstant_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_enumerationConstant_DropletFile;
    return this;
}

EnumerationConstant_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
EnumerationConstant_DropletFileContext.prototype.constructor = EnumerationConstant_DropletFileContext;

EnumerationConstant_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

EnumerationConstant_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

EnumerationConstant_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterEnumerationConstant_DropletFile(this);
	}
};

EnumerationConstant_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitEnumerationConstant_DropletFile(this);
	}
};




CParser.EnumerationConstant_DropletFileContext = EnumerationConstant_DropletFileContext;

CParser.prototype.enumerationConstant_DropletFile = function() {

    var localctx = new EnumerationConstant_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 258, CParser.RULE_enumerationConstant_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2102;
        this.match(CParser.Identifier);
        this.state = 2103;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AtomicTypeSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_atomicTypeSpecifier_DropletFile;
    return this;
}

AtomicTypeSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AtomicTypeSpecifier_DropletFileContext.prototype.constructor = AtomicTypeSpecifier_DropletFileContext;

AtomicTypeSpecifier_DropletFileContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

AtomicTypeSpecifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

AtomicTypeSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAtomicTypeSpecifier_DropletFile(this);
	}
};

AtomicTypeSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAtomicTypeSpecifier_DropletFile(this);
	}
};




CParser.AtomicTypeSpecifier_DropletFileContext = AtomicTypeSpecifier_DropletFileContext;

CParser.prototype.atomicTypeSpecifier_DropletFile = function() {

    var localctx = new AtomicTypeSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 260, CParser.RULE_atomicTypeSpecifier_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2105;
        this.match(CParser.Atomic);
        this.state = 2106;
        this.match(CParser.LeftParen);
        this.state = 2107;
        this.typeName();
        this.state = 2108;
        this.match(CParser.RightParen);
        this.state = 2109;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypeQualifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeQualifier_DropletFile;
    return this;
}

TypeQualifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeQualifier_DropletFileContext.prototype.constructor = TypeQualifier_DropletFileContext;

TypeQualifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

TypeQualifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeQualifier_DropletFile(this);
	}
};

TypeQualifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeQualifier_DropletFile(this);
	}
};




CParser.TypeQualifier_DropletFileContext = TypeQualifier_DropletFileContext;

CParser.prototype.typeQualifier_DropletFile = function() {

    var localctx = new TypeQualifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 262, CParser.RULE_typeQualifier_DropletFile);
    try {
        this.state = 2119;
        switch(this._input.LA(1)) {
        case CParser.Const:
            this.enterOuterAlt(localctx, 1);
            this.state = 2111;
            this.match(CParser.Const);
            this.state = 2112;
            this.match(CParser.EOF);
            break;
        case CParser.Restrict:
            this.enterOuterAlt(localctx, 2);
            this.state = 2113;
            this.match(CParser.Restrict);
            this.state = 2114;
            this.match(CParser.EOF);
            break;
        case CParser.Volatile:
            this.enterOuterAlt(localctx, 3);
            this.state = 2115;
            this.match(CParser.Volatile);
            this.state = 2116;
            this.match(CParser.EOF);
            break;
        case CParser.Atomic:
            this.enterOuterAlt(localctx, 4);
            this.state = 2117;
            this.match(CParser.Atomic);
            this.state = 2118;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function FunctionSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_functionSpecifier_DropletFile;
    return this;
}

FunctionSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
FunctionSpecifier_DropletFileContext.prototype.constructor = FunctionSpecifier_DropletFileContext;

FunctionSpecifier_DropletFileContext.prototype.EOF = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.EOF);
    } else {
        return this.getToken(CParser.EOF, i);
    }
};


FunctionSpecifier_DropletFileContext.prototype.gccAttributeSpecifier = function() {
    return this.getTypedRuleContext(GccAttributeSpecifierContext,0);
};

FunctionSpecifier_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

FunctionSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterFunctionSpecifier_DropletFile(this);
	}
};

FunctionSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitFunctionSpecifier_DropletFile(this);
	}
};




CParser.FunctionSpecifier_DropletFileContext = FunctionSpecifier_DropletFileContext;

CParser.prototype.functionSpecifier_DropletFile = function() {

    var localctx = new FunctionSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 264, CParser.RULE_functionSpecifier_DropletFile);
    try {
        this.state = 2138;
        switch(this._input.LA(1)) {
        case CParser.T__7:
        case CParser.T__8:
        case CParser.Inline:
        case CParser.Noreturn:
            this.enterOuterAlt(localctx, 1);
            this.state = 2127;
            switch(this._input.LA(1)) {
            case CParser.Inline:
                this.state = 2121;
                this.match(CParser.Inline);
                this.state = 2122;
                this.match(CParser.EOF);
                break;
            case CParser.Noreturn:
                this.state = 2123;
                this.match(CParser.Noreturn);
                this.state = 2124;
                this.match(CParser.EOF);
                break;
            case CParser.T__7:
                this.state = 2125;
                this.match(CParser.T__7);
                break;
            case CParser.T__8:
                this.state = 2126;
                this.match(CParser.T__8);
                break;
            default:
                throw new antlr4.error.NoViableAltException(this);
            }
            this.state = 2129;
            this.match(CParser.EOF);
            break;
        case CParser.T__11:
            this.enterOuterAlt(localctx, 2);
            this.state = 2130;
            this.gccAttributeSpecifier();
            this.state = 2131;
            this.match(CParser.EOF);
            break;
        case CParser.T__9:
            this.enterOuterAlt(localctx, 3);
            this.state = 2133;
            this.match(CParser.T__9);
            this.state = 2134;
            this.match(CParser.LeftParen);
            this.state = 2135;
            this.match(CParser.Identifier);
            this.state = 2136;
            this.match(CParser.RightParen);
            this.state = 2137;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AlignmentSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_alignmentSpecifier_DropletFile;
    return this;
}

AlignmentSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AlignmentSpecifier_DropletFileContext.prototype.constructor = AlignmentSpecifier_DropletFileContext;

AlignmentSpecifier_DropletFileContext.prototype.typeName = function() {
    return this.getTypedRuleContext(TypeNameContext,0);
};

AlignmentSpecifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

AlignmentSpecifier_DropletFileContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

AlignmentSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAlignmentSpecifier_DropletFile(this);
	}
};

AlignmentSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAlignmentSpecifier_DropletFile(this);
	}
};




CParser.AlignmentSpecifier_DropletFileContext = AlignmentSpecifier_DropletFileContext;

CParser.prototype.alignmentSpecifier_DropletFile = function() {

    var localctx = new AlignmentSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 266, CParser.RULE_alignmentSpecifier_DropletFile);
    try {
        this.state = 2152;
        var la_ = this._interp.adaptivePredict(this._input,194,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2140;
            this.match(CParser.Alignas);
            this.state = 2141;
            this.match(CParser.LeftParen);
            this.state = 2142;
            this.typeName();
            this.state = 2143;
            this.match(CParser.RightParen);
            this.state = 2144;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2146;
            this.match(CParser.Alignas);
            this.state = 2147;
            this.match(CParser.LeftParen);
            this.state = 2148;
            this.constantExpression();
            this.state = 2149;
            this.match(CParser.RightParen);
            this.state = 2150;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Declarator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarator_DropletFile;
    return this;
}

Declarator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Declarator_DropletFileContext.prototype.constructor = Declarator_DropletFileContext;

Declarator_DropletFileContext.prototype.directDeclarator = function() {
    return this.getTypedRuleContext(DirectDeclaratorContext,0);
};

Declarator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Declarator_DropletFileContext.prototype.pointer = function() {
    return this.getTypedRuleContext(PointerContext,0);
};

Declarator_DropletFileContext.prototype.gccDeclaratorExtension = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccDeclaratorExtensionContext);
    } else {
        return this.getTypedRuleContext(GccDeclaratorExtensionContext,i);
    }
};

Declarator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarator_DropletFile(this);
	}
};

Declarator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarator_DropletFile(this);
	}
};




CParser.Declarator_DropletFileContext = Declarator_DropletFileContext;

CParser.prototype.declarator_DropletFile = function() {

    var localctx = new Declarator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 268, CParser.RULE_declarator_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2155;
        _la = this._input.LA(1);
        if(_la===CParser.Star || _la===CParser.Caret) {
            this.state = 2154;
            this.pointer();
        }

        this.state = 2157;
        this.directDeclarator(0);
        this.state = 2161;
        this._errHandler.sync(this);
        _la = this._input.LA(1);
        while(_la===CParser.T__10 || _la===CParser.T__11) {
            this.state = 2158;
            this.gccDeclaratorExtension();
            this.state = 2163;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
        }
        this.state = 2164;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DirectDeclarator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_directDeclarator_DropletFile;
    return this;
}

DirectDeclarator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DirectDeclarator_DropletFileContext.prototype.constructor = DirectDeclarator_DropletFileContext;

DirectDeclarator_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

DirectDeclarator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

DirectDeclarator_DropletFileContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

DirectDeclarator_DropletFileContext.prototype.directDeclarator = function() {
    return this.getTypedRuleContext(DirectDeclaratorContext,0);
};

DirectDeclarator_DropletFileContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

DirectDeclarator_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

DirectDeclarator_DropletFileContext.prototype.parameterTypeList = function() {
    return this.getTypedRuleContext(ParameterTypeListContext,0);
};

DirectDeclarator_DropletFileContext.prototype.identifierList = function() {
    return this.getTypedRuleContext(IdentifierListContext,0);
};

DirectDeclarator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDirectDeclarator_DropletFile(this);
	}
};

DirectDeclarator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDirectDeclarator_DropletFile(this);
	}
};




CParser.DirectDeclarator_DropletFileContext = DirectDeclarator_DropletFileContext;

CParser.prototype.directDeclarator_DropletFile = function() {

    var localctx = new DirectDeclarator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 270, CParser.RULE_directDeclarator_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2225;
        var la_ = this._interp.adaptivePredict(this._input,202,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2166;
            this.match(CParser.Identifier);
            this.state = 2167;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2168;
            this.match(CParser.LeftParen);
            this.state = 2169;
            this.declarator();
            this.state = 2170;
            this.match(CParser.RightParen);
            this.state = 2171;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2173;
            this.directDeclarator(0);
            this.state = 2174;
            this.match(CParser.LeftBracket);
            this.state = 2176;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2175;
                this.typeQualifierList(0);
            }

            this.state = 2179;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2178;
                this.assignmentExpression();
            }

            this.state = 2181;
            this.match(CParser.RightBracket);
            this.state = 2182;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 2184;
            this.directDeclarator(0);
            this.state = 2185;
            this.match(CParser.LeftBracket);
            this.state = 2186;
            this.match(CParser.Static);
            this.state = 2188;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2187;
                this.typeQualifierList(0);
            }

            this.state = 2190;
            this.assignmentExpression();
            this.state = 2191;
            this.match(CParser.RightBracket);
            this.state = 2192;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 2194;
            this.directDeclarator(0);
            this.state = 2195;
            this.match(CParser.LeftBracket);
            this.state = 2196;
            this.typeQualifierList(0);
            this.state = 2197;
            this.match(CParser.Static);
            this.state = 2198;
            this.assignmentExpression();
            this.state = 2199;
            this.match(CParser.RightBracket);
            this.state = 2200;
            this.match(CParser.EOF);
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 2202;
            this.directDeclarator(0);
            this.state = 2203;
            this.match(CParser.LeftBracket);
            this.state = 2205;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2204;
                this.typeQualifierList(0);
            }

            this.state = 2207;
            this.match(CParser.Star);
            this.state = 2208;
            this.match(CParser.RightBracket);
            this.state = 2209;
            this.match(CParser.EOF);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 2211;
            this.directDeclarator(0);
            this.state = 2212;
            this.match(CParser.LeftParen);
            this.state = 2213;
            this.parameterTypeList();
            this.state = 2214;
            this.match(CParser.RightParen);
            this.state = 2215;
            this.match(CParser.EOF);
            break;

        case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 2217;
            this.directDeclarator(0);
            this.state = 2218;
            this.match(CParser.LeftParen);
            this.state = 2220;
            _la = this._input.LA(1);
            if(_la===CParser.Identifier) {
                this.state = 2219;
                this.identifierList(0);
            }

            this.state = 2222;
            this.match(CParser.RightParen);
            this.state = 2223;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GccDeclaratorExtension_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccDeclaratorExtension_DropletFile;
    return this;
}

GccDeclaratorExtension_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccDeclaratorExtension_DropletFileContext.prototype.constructor = GccDeclaratorExtension_DropletFileContext;

GccDeclaratorExtension_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

GccDeclaratorExtension_DropletFileContext.prototype.StringLiteral = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.StringLiteral);
    } else {
        return this.getToken(CParser.StringLiteral, i);
    }
};


GccDeclaratorExtension_DropletFileContext.prototype.gccAttributeSpecifier = function() {
    return this.getTypedRuleContext(GccAttributeSpecifierContext,0);
};

GccDeclaratorExtension_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccDeclaratorExtension_DropletFile(this);
	}
};

GccDeclaratorExtension_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccDeclaratorExtension_DropletFile(this);
	}
};




CParser.GccDeclaratorExtension_DropletFileContext = GccDeclaratorExtension_DropletFileContext;

CParser.prototype.gccDeclaratorExtension_DropletFile = function() {

    var localctx = new GccDeclaratorExtension_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 272, CParser.RULE_gccDeclaratorExtension_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2239;
        switch(this._input.LA(1)) {
        case CParser.T__10:
            this.enterOuterAlt(localctx, 1);
            this.state = 2227;
            this.match(CParser.T__10);
            this.state = 2228;
            this.match(CParser.LeftParen);
            this.state = 2230; 
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            do {
                this.state = 2229;
                this.match(CParser.StringLiteral);
                this.state = 2232; 
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            } while(_la===CParser.StringLiteral);
            this.state = 2234;
            this.match(CParser.RightParen);
            this.state = 2235;
            this.match(CParser.EOF);
            break;
        case CParser.T__11:
            this.enterOuterAlt(localctx, 2);
            this.state = 2236;
            this.gccAttributeSpecifier();
            this.state = 2237;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GccAttributeSpecifier_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccAttributeSpecifier_DropletFile;
    return this;
}

GccAttributeSpecifier_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccAttributeSpecifier_DropletFileContext.prototype.constructor = GccAttributeSpecifier_DropletFileContext;

GccAttributeSpecifier_DropletFileContext.prototype.gccAttributeList = function() {
    return this.getTypedRuleContext(GccAttributeListContext,0);
};

GccAttributeSpecifier_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

GccAttributeSpecifier_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccAttributeSpecifier_DropletFile(this);
	}
};

GccAttributeSpecifier_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccAttributeSpecifier_DropletFile(this);
	}
};




CParser.GccAttributeSpecifier_DropletFileContext = GccAttributeSpecifier_DropletFileContext;

CParser.prototype.gccAttributeSpecifier_DropletFile = function() {

    var localctx = new GccAttributeSpecifier_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 274, CParser.RULE_gccAttributeSpecifier_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2241;
        this.match(CParser.T__11);
        this.state = 2242;
        this.match(CParser.LeftParen);
        this.state = 2243;
        this.match(CParser.LeftParen);
        this.state = 2244;
        this.gccAttributeList();
        this.state = 2245;
        this.match(CParser.RightParen);
        this.state = 2246;
        this.match(CParser.RightParen);
        this.state = 2247;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GccAttributeList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccAttributeList_DropletFile;
    return this;
}

GccAttributeList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccAttributeList_DropletFileContext.prototype.constructor = GccAttributeList_DropletFileContext;

GccAttributeList_DropletFileContext.prototype.gccAttribute = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccAttributeContext);
    } else {
        return this.getTypedRuleContext(GccAttributeContext,i);
    }
};

GccAttributeList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

GccAttributeList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccAttributeList_DropletFile(this);
	}
};

GccAttributeList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccAttributeList_DropletFile(this);
	}
};




CParser.GccAttributeList_DropletFileContext = GccAttributeList_DropletFileContext;

CParser.prototype.gccAttributeList_DropletFile = function() {

    var localctx = new GccAttributeList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 276, CParser.RULE_gccAttributeList_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2260;
        var la_ = this._interp.adaptivePredict(this._input,206,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2249;
            this.gccAttribute();
            this.state = 2254;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.Comma) {
                this.state = 2250;
                this.match(CParser.Comma);
                this.state = 2251;
                this.gccAttribute();
                this.state = 2256;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            this.state = 2257;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);

            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function GccAttribute_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_gccAttribute_DropletFile;
    return this;
}

GccAttribute_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
GccAttribute_DropletFileContext.prototype.constructor = GccAttribute_DropletFileContext;

GccAttribute_DropletFileContext.prototype.argumentExpressionList = function() {
    return this.getTypedRuleContext(ArgumentExpressionListContext,0);
};

GccAttribute_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterGccAttribute_DropletFile(this);
	}
};

GccAttribute_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitGccAttribute_DropletFile(this);
	}
};




CParser.GccAttribute_DropletFileContext = GccAttribute_DropletFileContext;

CParser.prototype.gccAttribute_DropletFile = function() {

    var localctx = new GccAttribute_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 278, CParser.RULE_gccAttribute_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2271;
        switch(this._input.LA(1)) {
        case CParser.T__0:
        case CParser.T__1:
        case CParser.T__2:
        case CParser.T__3:
        case CParser.T__4:
        case CParser.T__5:
        case CParser.T__6:
        case CParser.T__7:
        case CParser.T__8:
        case CParser.T__9:
        case CParser.T__10:
        case CParser.T__11:
        case CParser.T__12:
        case CParser.T__13:
        case CParser.Auto:
        case CParser.Break:
        case CParser.Case:
        case CParser.Char:
        case CParser.Const:
        case CParser.Continue:
        case CParser.Default:
        case CParser.Do:
        case CParser.Double:
        case CParser.Else:
        case CParser.Enum:
        case CParser.Extern:
        case CParser.Float:
        case CParser.For:
        case CParser.Goto:
        case CParser.If:
        case CParser.Inline:
        case CParser.Int:
        case CParser.Long:
        case CParser.Register:
        case CParser.Restrict:
        case CParser.Return:
        case CParser.Short:
        case CParser.Signed:
        case CParser.Sizeof:
        case CParser.Static:
        case CParser.Struct:
        case CParser.Switch:
        case CParser.Typedef:
        case CParser.Union:
        case CParser.Unsigned:
        case CParser.Void:
        case CParser.Volatile:
        case CParser.While:
        case CParser.Alignas:
        case CParser.Alignof:
        case CParser.Atomic:
        case CParser.Bool:
        case CParser.Complex:
        case CParser.Generic:
        case CParser.Imaginary:
        case CParser.Noreturn:
        case CParser.StaticAssert:
        case CParser.ThreadLocal:
        case CParser.LeftBracket:
        case CParser.RightBracket:
        case CParser.LeftBrace:
        case CParser.RightBrace:
        case CParser.Less:
        case CParser.LessEqual:
        case CParser.Greater:
        case CParser.GreaterEqual:
        case CParser.LeftShift:
        case CParser.RightShift:
        case CParser.Plus:
        case CParser.PlusPlus:
        case CParser.Minus:
        case CParser.MinusMinus:
        case CParser.Star:
        case CParser.Div:
        case CParser.Mod:
        case CParser.And:
        case CParser.Or:
        case CParser.AndAnd:
        case CParser.OrOr:
        case CParser.Caret:
        case CParser.Not:
        case CParser.Tilde:
        case CParser.Question:
        case CParser.Colon:
        case CParser.Semi:
        case CParser.Assign:
        case CParser.StarAssign:
        case CParser.DivAssign:
        case CParser.ModAssign:
        case CParser.PlusAssign:
        case CParser.MinusAssign:
        case CParser.LeftShiftAssign:
        case CParser.RightShiftAssign:
        case CParser.AndAssign:
        case CParser.XorAssign:
        case CParser.OrAssign:
        case CParser.Equal:
        case CParser.NotEqual:
        case CParser.Arrow:
        case CParser.Dot:
        case CParser.Ellipsis:
        case CParser.Identifier:
        case CParser.Constant:
        case CParser.StringLiteral:
        case CParser.Directive:
        case CParser.Whitespace:
        case CParser.Newline:
        case CParser.BlockComment:
        case CParser.LineComment:
            this.enterOuterAlt(localctx, 1);
            this.state = 2262;
            _la = this._input.LA(1);
            if(_la<=0 || ((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.RightParen - 59)) | (1 << (CParser.Comma - 59)))) !== 0)) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 2268;
            _la = this._input.LA(1);
            if(_la===CParser.LeftParen) {
                this.state = 2263;
                this.match(CParser.LeftParen);
                this.state = 2265;
                _la = this._input.LA(1);
                if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                    this.state = 2264;
                    this.argumentExpressionList(0);
                }

                this.state = 2267;
                this.match(CParser.RightParen);
            }

            break;
        case CParser.EOF:
            this.enterOuterAlt(localctx, 2);

            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function NestedParenthesesBlock_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_nestedParenthesesBlock_DropletFile;
    return this;
}

NestedParenthesesBlock_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
NestedParenthesesBlock_DropletFileContext.prototype.constructor = NestedParenthesesBlock_DropletFileContext;

NestedParenthesesBlock_DropletFileContext.prototype.EOF = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.EOF);
    } else {
        return this.getToken(CParser.EOF, i);
    }
};


NestedParenthesesBlock_DropletFileContext.prototype.nestedParenthesesBlock = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(NestedParenthesesBlockContext);
    } else {
        return this.getTypedRuleContext(NestedParenthesesBlockContext,i);
    }
};

NestedParenthesesBlock_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterNestedParenthesesBlock_DropletFile(this);
	}
};

NestedParenthesesBlock_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitNestedParenthesesBlock_DropletFile(this);
	}
};




CParser.NestedParenthesesBlock_DropletFileContext = NestedParenthesesBlock_DropletFileContext;

CParser.prototype.nestedParenthesesBlock_DropletFile = function() {

    var localctx = new NestedParenthesesBlock_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 280, CParser.RULE_nestedParenthesesBlock_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2282;
        this._errHandler.sync(this);
        _la = this._input.LA(1);
        while((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.T__13) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Else) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Return - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Sizeof - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Switch - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.While - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Alignof - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Generic - 32)) | (1 << (CParser.Imaginary - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)) | (1 << (CParser.LeftParen - 32)) | (1 << (CParser.LeftBracket - 32)) | (1 << (CParser.RightBracket - 32)) | (1 << (CParser.LeftBrace - 32)))) !== 0) || ((((_la - 64)) & ~0x1f) == 0 && ((1 << (_la - 64)) & ((1 << (CParser.RightBrace - 64)) | (1 << (CParser.Less - 64)) | (1 << (CParser.LessEqual - 64)) | (1 << (CParser.Greater - 64)) | (1 << (CParser.GreaterEqual - 64)) | (1 << (CParser.LeftShift - 64)) | (1 << (CParser.RightShift - 64)) | (1 << (CParser.Plus - 64)) | (1 << (CParser.PlusPlus - 64)) | (1 << (CParser.Minus - 64)) | (1 << (CParser.MinusMinus - 64)) | (1 << (CParser.Star - 64)) | (1 << (CParser.Div - 64)) | (1 << (CParser.Mod - 64)) | (1 << (CParser.And - 64)) | (1 << (CParser.Or - 64)) | (1 << (CParser.AndAnd - 64)) | (1 << (CParser.OrOr - 64)) | (1 << (CParser.Caret - 64)) | (1 << (CParser.Not - 64)) | (1 << (CParser.Tilde - 64)) | (1 << (CParser.Question - 64)) | (1 << (CParser.Colon - 64)) | (1 << (CParser.Semi - 64)) | (1 << (CParser.Comma - 64)) | (1 << (CParser.Assign - 64)) | (1 << (CParser.StarAssign - 64)) | (1 << (CParser.DivAssign - 64)) | (1 << (CParser.ModAssign - 64)) | (1 << (CParser.PlusAssign - 64)) | (1 << (CParser.MinusAssign - 64)) | (1 << (CParser.LeftShiftAssign - 64)))) !== 0) || ((((_la - 96)) & ~0x1f) == 0 && ((1 << (_la - 96)) & ((1 << (CParser.RightShiftAssign - 96)) | (1 << (CParser.AndAssign - 96)) | (1 << (CParser.XorAssign - 96)) | (1 << (CParser.OrAssign - 96)) | (1 << (CParser.Equal - 96)) | (1 << (CParser.NotEqual - 96)) | (1 << (CParser.Arrow - 96)) | (1 << (CParser.Dot - 96)) | (1 << (CParser.Ellipsis - 96)) | (1 << (CParser.Identifier - 96)) | (1 << (CParser.Constant - 96)) | (1 << (CParser.StringLiteral - 96)) | (1 << (CParser.Directive - 96)) | (1 << (CParser.Whitespace - 96)) | (1 << (CParser.Newline - 96)) | (1 << (CParser.BlockComment - 96)) | (1 << (CParser.LineComment - 96)))) !== 0)) {
            this.state = 2280;
            switch(this._input.LA(1)) {
            case CParser.T__0:
            case CParser.T__1:
            case CParser.T__2:
            case CParser.T__3:
            case CParser.T__4:
            case CParser.T__5:
            case CParser.T__6:
            case CParser.T__7:
            case CParser.T__8:
            case CParser.T__9:
            case CParser.T__10:
            case CParser.T__11:
            case CParser.T__12:
            case CParser.T__13:
            case CParser.Auto:
            case CParser.Break:
            case CParser.Case:
            case CParser.Char:
            case CParser.Const:
            case CParser.Continue:
            case CParser.Default:
            case CParser.Do:
            case CParser.Double:
            case CParser.Else:
            case CParser.Enum:
            case CParser.Extern:
            case CParser.Float:
            case CParser.For:
            case CParser.Goto:
            case CParser.If:
            case CParser.Inline:
            case CParser.Int:
            case CParser.Long:
            case CParser.Register:
            case CParser.Restrict:
            case CParser.Return:
            case CParser.Short:
            case CParser.Signed:
            case CParser.Sizeof:
            case CParser.Static:
            case CParser.Struct:
            case CParser.Switch:
            case CParser.Typedef:
            case CParser.Union:
            case CParser.Unsigned:
            case CParser.Void:
            case CParser.Volatile:
            case CParser.While:
            case CParser.Alignas:
            case CParser.Alignof:
            case CParser.Atomic:
            case CParser.Bool:
            case CParser.Complex:
            case CParser.Generic:
            case CParser.Imaginary:
            case CParser.Noreturn:
            case CParser.StaticAssert:
            case CParser.ThreadLocal:
            case CParser.LeftBracket:
            case CParser.RightBracket:
            case CParser.LeftBrace:
            case CParser.RightBrace:
            case CParser.Less:
            case CParser.LessEqual:
            case CParser.Greater:
            case CParser.GreaterEqual:
            case CParser.LeftShift:
            case CParser.RightShift:
            case CParser.Plus:
            case CParser.PlusPlus:
            case CParser.Minus:
            case CParser.MinusMinus:
            case CParser.Star:
            case CParser.Div:
            case CParser.Mod:
            case CParser.And:
            case CParser.Or:
            case CParser.AndAnd:
            case CParser.OrOr:
            case CParser.Caret:
            case CParser.Not:
            case CParser.Tilde:
            case CParser.Question:
            case CParser.Colon:
            case CParser.Semi:
            case CParser.Comma:
            case CParser.Assign:
            case CParser.StarAssign:
            case CParser.DivAssign:
            case CParser.ModAssign:
            case CParser.PlusAssign:
            case CParser.MinusAssign:
            case CParser.LeftShiftAssign:
            case CParser.RightShiftAssign:
            case CParser.AndAssign:
            case CParser.XorAssign:
            case CParser.OrAssign:
            case CParser.Equal:
            case CParser.NotEqual:
            case CParser.Arrow:
            case CParser.Dot:
            case CParser.Ellipsis:
            case CParser.Identifier:
            case CParser.Constant:
            case CParser.StringLiteral:
            case CParser.Directive:
            case CParser.Whitespace:
            case CParser.Newline:
            case CParser.BlockComment:
            case CParser.LineComment:
                this.state = 2273;
                _la = this._input.LA(1);
                if(_la<=0 || _la===CParser.LeftParen || _la===CParser.RightParen) {
                this._errHandler.recoverInline(this);
                }
                else {
                    this.consume();
                }
                this.state = 2274;
                this.match(CParser.EOF);
                break;
            case CParser.LeftParen:
                this.state = 2275;
                this.match(CParser.LeftParen);
                this.state = 2276;
                this.nestedParenthesesBlock();
                this.state = 2277;
                this.match(CParser.RightParen);
                this.state = 2278;
                this.match(CParser.EOF);
                break;
            default:
                throw new antlr4.error.NoViableAltException(this);
            }
            this.state = 2284;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Pointer_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_pointer_DropletFile;
    return this;
}

Pointer_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Pointer_DropletFileContext.prototype.constructor = Pointer_DropletFileContext;

Pointer_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Pointer_DropletFileContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

Pointer_DropletFileContext.prototype.pointer = function() {
    return this.getTypedRuleContext(PointerContext,0);
};

Pointer_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterPointer_DropletFile(this);
	}
};

Pointer_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitPointer_DropletFile(this);
	}
};




CParser.Pointer_DropletFileContext = Pointer_DropletFileContext;

CParser.prototype.pointer_DropletFile = function() {

    var localctx = new Pointer_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 282, CParser.RULE_pointer_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2306;
        var la_ = this._interp.adaptivePredict(this._input,216,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2285;
            this.match(CParser.Star);
            this.state = 2287;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2286;
                this.typeQualifierList(0);
            }

            this.state = 2289;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2290;
            this.match(CParser.Star);
            this.state = 2292;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2291;
                this.typeQualifierList(0);
            }

            this.state = 2294;
            this.pointer();
            this.state = 2295;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2297;
            this.match(CParser.Caret);
            this.state = 2299;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2298;
                this.typeQualifierList(0);
            }

            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 2301;
            this.match(CParser.Caret);
            this.state = 2303;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2302;
                this.typeQualifierList(0);
            }

            this.state = 2305;
            this.pointer();
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypeQualifierList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeQualifierList_DropletFile;
    return this;
}

TypeQualifierList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeQualifierList_DropletFileContext.prototype.constructor = TypeQualifierList_DropletFileContext;

TypeQualifierList_DropletFileContext.prototype.typeQualifier = function() {
    return this.getTypedRuleContext(TypeQualifierContext,0);
};

TypeQualifierList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

TypeQualifierList_DropletFileContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

TypeQualifierList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeQualifierList_DropletFile(this);
	}
};

TypeQualifierList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeQualifierList_DropletFile(this);
	}
};




CParser.TypeQualifierList_DropletFileContext = TypeQualifierList_DropletFileContext;

CParser.prototype.typeQualifierList_DropletFile = function() {

    var localctx = new TypeQualifierList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 284, CParser.RULE_typeQualifierList_DropletFile);
    try {
        this.state = 2315;
        var la_ = this._interp.adaptivePredict(this._input,217,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2308;
            this.typeQualifier();
            this.state = 2309;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2311;
            this.typeQualifierList(0);
            this.state = 2312;
            this.typeQualifier();
            this.state = 2313;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ParameterTypeList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_parameterTypeList_DropletFile;
    return this;
}

ParameterTypeList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ParameterTypeList_DropletFileContext.prototype.constructor = ParameterTypeList_DropletFileContext;

ParameterTypeList_DropletFileContext.prototype.parameterList = function() {
    return this.getTypedRuleContext(ParameterListContext,0);
};

ParameterTypeList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ParameterTypeList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterParameterTypeList_DropletFile(this);
	}
};

ParameterTypeList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitParameterTypeList_DropletFile(this);
	}
};




CParser.ParameterTypeList_DropletFileContext = ParameterTypeList_DropletFileContext;

CParser.prototype.parameterTypeList_DropletFile = function() {

    var localctx = new ParameterTypeList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 286, CParser.RULE_parameterTypeList_DropletFile);
    try {
        this.state = 2325;
        var la_ = this._interp.adaptivePredict(this._input,218,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2317;
            this.parameterList(0);
            this.state = 2318;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2320;
            this.parameterList(0);
            this.state = 2321;
            this.match(CParser.Comma);
            this.state = 2322;
            this.match(CParser.Ellipsis);
            this.state = 2323;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ParameterList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_parameterList_DropletFile;
    return this;
}

ParameterList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ParameterList_DropletFileContext.prototype.constructor = ParameterList_DropletFileContext;

ParameterList_DropletFileContext.prototype.parameterDeclaration = function() {
    return this.getTypedRuleContext(ParameterDeclarationContext,0);
};

ParameterList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ParameterList_DropletFileContext.prototype.parameterList = function() {
    return this.getTypedRuleContext(ParameterListContext,0);
};

ParameterList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterParameterList_DropletFile(this);
	}
};

ParameterList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitParameterList_DropletFile(this);
	}
};




CParser.ParameterList_DropletFileContext = ParameterList_DropletFileContext;

CParser.prototype.parameterList_DropletFile = function() {

    var localctx = new ParameterList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 288, CParser.RULE_parameterList_DropletFile);
    try {
        this.state = 2335;
        var la_ = this._interp.adaptivePredict(this._input,219,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2327;
            this.parameterDeclaration();
            this.state = 2328;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2330;
            this.parameterList(0);
            this.state = 2331;
            this.match(CParser.Comma);
            this.state = 2332;
            this.parameterDeclaration();
            this.state = 2333;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ParameterDeclaration_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_parameterDeclaration_DropletFile;
    return this;
}

ParameterDeclaration_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ParameterDeclaration_DropletFileContext.prototype.constructor = ParameterDeclaration_DropletFileContext;

ParameterDeclaration_DropletFileContext.prototype.declarationSpecifiers = function() {
    return this.getTypedRuleContext(DeclarationSpecifiersContext,0);
};

ParameterDeclaration_DropletFileContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

ParameterDeclaration_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ParameterDeclaration_DropletFileContext.prototype.declarationSpecifiers2 = function() {
    return this.getTypedRuleContext(DeclarationSpecifiers2Context,0);
};

ParameterDeclaration_DropletFileContext.prototype.abstractDeclarator = function() {
    return this.getTypedRuleContext(AbstractDeclaratorContext,0);
};

ParameterDeclaration_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterParameterDeclaration_DropletFile(this);
	}
};

ParameterDeclaration_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitParameterDeclaration_DropletFile(this);
	}
};




CParser.ParameterDeclaration_DropletFileContext = ParameterDeclaration_DropletFileContext;

CParser.prototype.parameterDeclaration_DropletFile = function() {

    var localctx = new ParameterDeclaration_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 290, CParser.RULE_parameterDeclaration_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2347;
        var la_ = this._interp.adaptivePredict(this._input,221,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2337;
            this.declarationSpecifiers();
            this.state = 2338;
            this.declarator();
            this.state = 2339;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2341;
            this.declarationSpecifiers2();
            this.state = 2343;
            _la = this._input.LA(1);
            if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.LeftBracket - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) !== 0)) {
                this.state = 2342;
                this.abstractDeclarator();
            }

            this.state = 2345;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function IdentifierList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_identifierList_DropletFile;
    return this;
}

IdentifierList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
IdentifierList_DropletFileContext.prototype.constructor = IdentifierList_DropletFileContext;

IdentifierList_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

IdentifierList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

IdentifierList_DropletFileContext.prototype.identifierList = function() {
    return this.getTypedRuleContext(IdentifierListContext,0);
};

IdentifierList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterIdentifierList_DropletFile(this);
	}
};

IdentifierList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitIdentifierList_DropletFile(this);
	}
};




CParser.IdentifierList_DropletFileContext = IdentifierList_DropletFileContext;

CParser.prototype.identifierList_DropletFile = function() {

    var localctx = new IdentifierList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 292, CParser.RULE_identifierList_DropletFile);
    try {
        this.state = 2356;
        var la_ = this._interp.adaptivePredict(this._input,222,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2349;
            this.match(CParser.Identifier);
            this.state = 2350;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2351;
            this.identifierList(0);
            this.state = 2352;
            this.match(CParser.Comma);
            this.state = 2353;
            this.match(CParser.Identifier);
            this.state = 2354;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypeName_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typeName_DropletFile;
    return this;
}

TypeName_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypeName_DropletFileContext.prototype.constructor = TypeName_DropletFileContext;

TypeName_DropletFileContext.prototype.specifierQualifierList = function() {
    return this.getTypedRuleContext(SpecifierQualifierListContext,0);
};

TypeName_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

TypeName_DropletFileContext.prototype.abstractDeclarator = function() {
    return this.getTypedRuleContext(AbstractDeclaratorContext,0);
};

TypeName_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypeName_DropletFile(this);
	}
};

TypeName_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypeName_DropletFile(this);
	}
};




CParser.TypeName_DropletFileContext = TypeName_DropletFileContext;

CParser.prototype.typeName_DropletFile = function() {

    var localctx = new TypeName_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 294, CParser.RULE_typeName_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2358;
        this.specifierQualifierList();
        this.state = 2360;
        _la = this._input.LA(1);
        if(((((_la - 59)) & ~0x1f) == 0 && ((1 << (_la - 59)) & ((1 << (CParser.LeftParen - 59)) | (1 << (CParser.LeftBracket - 59)) | (1 << (CParser.Star - 59)) | (1 << (CParser.Caret - 59)))) !== 0)) {
            this.state = 2359;
            this.abstractDeclarator();
        }

        this.state = 2362;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function AbstractDeclarator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_abstractDeclarator_DropletFile;
    return this;
}

AbstractDeclarator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
AbstractDeclarator_DropletFileContext.prototype.constructor = AbstractDeclarator_DropletFileContext;

AbstractDeclarator_DropletFileContext.prototype.pointer = function() {
    return this.getTypedRuleContext(PointerContext,0);
};

AbstractDeclarator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

AbstractDeclarator_DropletFileContext.prototype.directAbstractDeclarator = function() {
    return this.getTypedRuleContext(DirectAbstractDeclaratorContext,0);
};

AbstractDeclarator_DropletFileContext.prototype.gccDeclaratorExtension = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccDeclaratorExtensionContext);
    } else {
        return this.getTypedRuleContext(GccDeclaratorExtensionContext,i);
    }
};

AbstractDeclarator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterAbstractDeclarator_DropletFile(this);
	}
};

AbstractDeclarator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitAbstractDeclarator_DropletFile(this);
	}
};




CParser.AbstractDeclarator_DropletFileContext = AbstractDeclarator_DropletFileContext;

CParser.prototype.abstractDeclarator_DropletFile = function() {

    var localctx = new AbstractDeclarator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 296, CParser.RULE_abstractDeclarator_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2379;
        var la_ = this._interp.adaptivePredict(this._input,226,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2364;
            this.pointer();
            this.state = 2365;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2368;
            _la = this._input.LA(1);
            if(_la===CParser.Star || _la===CParser.Caret) {
                this.state = 2367;
                this.pointer();
            }

            this.state = 2370;
            this.directAbstractDeclarator(0);
            this.state = 2374;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.T__10 || _la===CParser.T__11) {
                this.state = 2371;
                this.gccDeclaratorExtension();
                this.state = 2376;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            this.state = 2377;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DirectAbstractDeclarator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_directAbstractDeclarator_DropletFile;
    return this;
}

DirectAbstractDeclarator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DirectAbstractDeclarator_DropletFileContext.prototype.constructor = DirectAbstractDeclarator_DropletFileContext;

DirectAbstractDeclarator_DropletFileContext.prototype.abstractDeclarator = function() {
    return this.getTypedRuleContext(AbstractDeclaratorContext,0);
};

DirectAbstractDeclarator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

DirectAbstractDeclarator_DropletFileContext.prototype.gccDeclaratorExtension = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(GccDeclaratorExtensionContext);
    } else {
        return this.getTypedRuleContext(GccDeclaratorExtensionContext,i);
    }
};

DirectAbstractDeclarator_DropletFileContext.prototype.typeQualifierList = function() {
    return this.getTypedRuleContext(TypeQualifierListContext,0);
};

DirectAbstractDeclarator_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

DirectAbstractDeclarator_DropletFileContext.prototype.parameterTypeList = function() {
    return this.getTypedRuleContext(ParameterTypeListContext,0);
};

DirectAbstractDeclarator_DropletFileContext.prototype.directAbstractDeclarator = function() {
    return this.getTypedRuleContext(DirectAbstractDeclaratorContext,0);
};

DirectAbstractDeclarator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDirectAbstractDeclarator_DropletFile(this);
	}
};

DirectAbstractDeclarator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDirectAbstractDeclarator_DropletFile(this);
	}
};




CParser.DirectAbstractDeclarator_DropletFileContext = DirectAbstractDeclarator_DropletFileContext;

CParser.prototype.directAbstractDeclarator_DropletFile = function() {

    var localctx = new DirectAbstractDeclarator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 298, CParser.RULE_directAbstractDeclarator_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2482;
        var la_ = this._interp.adaptivePredict(this._input,238,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2381;
            this.match(CParser.LeftParen);
            this.state = 2382;
            this.abstractDeclarator();
            this.state = 2383;
            this.match(CParser.RightParen);
            this.state = 2387;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.T__10 || _la===CParser.T__11) {
                this.state = 2384;
                this.gccDeclaratorExtension();
                this.state = 2389;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            this.state = 2390;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2392;
            this.match(CParser.LeftBracket);
            this.state = 2394;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2393;
                this.typeQualifierList(0);
            }

            this.state = 2397;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2396;
                this.assignmentExpression();
            }

            this.state = 2399;
            this.match(CParser.RightBracket);
            this.state = 2400;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2401;
            this.match(CParser.LeftBracket);
            this.state = 2402;
            this.match(CParser.Static);
            this.state = 2404;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2403;
                this.typeQualifierList(0);
            }

            this.state = 2406;
            this.assignmentExpression();
            this.state = 2407;
            this.match(CParser.RightBracket);
            this.state = 2408;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 2410;
            this.match(CParser.LeftBracket);
            this.state = 2411;
            this.typeQualifierList(0);
            this.state = 2412;
            this.match(CParser.Static);
            this.state = 2413;
            this.assignmentExpression();
            this.state = 2414;
            this.match(CParser.RightBracket);
            this.state = 2415;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 2417;
            this.match(CParser.LeftBracket);
            this.state = 2418;
            this.match(CParser.Star);
            this.state = 2419;
            this.match(CParser.RightBracket);
            this.state = 2420;
            this.match(CParser.EOF);
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 2421;
            this.match(CParser.LeftParen);
            this.state = 2423;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier) {
                this.state = 2422;
                this.parameterTypeList();
            }

            this.state = 2425;
            this.match(CParser.RightParen);
            this.state = 2429;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.T__10 || _la===CParser.T__11) {
                this.state = 2426;
                this.gccDeclaratorExtension();
                this.state = 2431;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            this.state = 2432;
            this.match(CParser.EOF);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 2433;
            this.directAbstractDeclarator(0);
            this.state = 2434;
            this.match(CParser.LeftBracket);
            this.state = 2436;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2435;
                this.typeQualifierList(0);
            }

            this.state = 2439;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2438;
                this.assignmentExpression();
            }

            this.state = 2441;
            this.match(CParser.RightBracket);
            this.state = 2442;
            this.match(CParser.EOF);
            break;

        case 8:
            this.enterOuterAlt(localctx, 8);
            this.state = 2444;
            this.directAbstractDeclarator(0);
            this.state = 2445;
            this.match(CParser.LeftBracket);
            this.state = 2446;
            this.match(CParser.Static);
            this.state = 2448;
            _la = this._input.LA(1);
            if(_la===CParser.Const || ((((_la - 35)) & ~0x1f) == 0 && ((1 << (_la - 35)) & ((1 << (CParser.Restrict - 35)) | (1 << (CParser.Volatile - 35)) | (1 << (CParser.Atomic - 35)))) !== 0)) {
                this.state = 2447;
                this.typeQualifierList(0);
            }

            this.state = 2450;
            this.assignmentExpression();
            this.state = 2451;
            this.match(CParser.RightBracket);
            this.state = 2452;
            this.match(CParser.EOF);
            break;

        case 9:
            this.enterOuterAlt(localctx, 9);
            this.state = 2454;
            this.directAbstractDeclarator(0);
            this.state = 2455;
            this.match(CParser.LeftBracket);
            this.state = 2456;
            this.typeQualifierList(0);
            this.state = 2457;
            this.match(CParser.Static);
            this.state = 2458;
            this.assignmentExpression();
            this.state = 2459;
            this.match(CParser.RightBracket);
            this.state = 2460;
            this.match(CParser.EOF);
            break;

        case 10:
            this.enterOuterAlt(localctx, 10);
            this.state = 2462;
            this.directAbstractDeclarator(0);
            this.state = 2463;
            this.match(CParser.LeftBracket);
            this.state = 2464;
            this.match(CParser.Star);
            this.state = 2465;
            this.match(CParser.RightBracket);
            this.state = 2466;
            this.match(CParser.EOF);
            break;

        case 11:
            this.enterOuterAlt(localctx, 11);
            this.state = 2468;
            this.directAbstractDeclarator(0);
            this.state = 2469;
            this.match(CParser.LeftParen);
            this.state = 2471;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier) {
                this.state = 2470;
                this.parameterTypeList();
            }

            this.state = 2473;
            this.match(CParser.RightParen);
            this.state = 2477;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.T__10 || _la===CParser.T__11) {
                this.state = 2474;
                this.gccDeclaratorExtension();
                this.state = 2479;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            this.state = 2480;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TypedefName_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_typedefName_DropletFile;
    return this;
}

TypedefName_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TypedefName_DropletFileContext.prototype.constructor = TypedefName_DropletFileContext;

TypedefName_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

TypedefName_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

TypedefName_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTypedefName_DropletFile(this);
	}
};

TypedefName_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTypedefName_DropletFile(this);
	}
};




CParser.TypedefName_DropletFileContext = TypedefName_DropletFileContext;

CParser.prototype.typedefName_DropletFile = function() {

    var localctx = new TypedefName_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 300, CParser.RULE_typedefName_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2484;
        this.match(CParser.Identifier);
        this.state = 2485;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Initializer_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initializer_DropletFile;
    return this;
}

Initializer_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Initializer_DropletFileContext.prototype.constructor = Initializer_DropletFileContext;

Initializer_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

Initializer_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Initializer_DropletFileContext.prototype.initializerList = function() {
    return this.getTypedRuleContext(InitializerListContext,0);
};

Initializer_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitializer_DropletFile(this);
	}
};

Initializer_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitializer_DropletFile(this);
	}
};




CParser.Initializer_DropletFileContext = Initializer_DropletFileContext;

CParser.prototype.initializer_DropletFile = function() {

    var localctx = new Initializer_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 302, CParser.RULE_initializer_DropletFile);
    try {
        this.state = 2501;
        var la_ = this._interp.adaptivePredict(this._input,239,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2487;
            this.assignmentExpression();
            this.state = 2488;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2490;
            this.match(CParser.LeftBrace);
            this.state = 2491;
            this.initializerList(0);
            this.state = 2492;
            this.match(CParser.RightBrace);
            this.state = 2493;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2495;
            this.match(CParser.LeftBrace);
            this.state = 2496;
            this.initializerList(0);
            this.state = 2497;
            this.match(CParser.Comma);
            this.state = 2498;
            this.match(CParser.RightBrace);
            this.state = 2499;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function InitializerList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_initializerList_DropletFile;
    return this;
}

InitializerList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
InitializerList_DropletFileContext.prototype.constructor = InitializerList_DropletFileContext;

InitializerList_DropletFileContext.prototype.initializer = function() {
    return this.getTypedRuleContext(InitializerContext,0);
};

InitializerList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

InitializerList_DropletFileContext.prototype.designation = function() {
    return this.getTypedRuleContext(DesignationContext,0);
};

InitializerList_DropletFileContext.prototype.initializerList = function() {
    return this.getTypedRuleContext(InitializerListContext,0);
};

InitializerList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterInitializerList_DropletFile(this);
	}
};

InitializerList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitInitializerList_DropletFile(this);
	}
};




CParser.InitializerList_DropletFileContext = InitializerList_DropletFileContext;

CParser.prototype.initializerList_DropletFile = function() {

    var localctx = new InitializerList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 304, CParser.RULE_initializerList_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2517;
        var la_ = this._interp.adaptivePredict(this._input,242,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2504;
            _la = this._input.LA(1);
            if(_la===CParser.LeftBracket || _la===CParser.Dot) {
                this.state = 2503;
                this.designation();
            }

            this.state = 2506;
            this.initializer();
            this.state = 2507;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2509;
            this.initializerList(0);
            this.state = 2510;
            this.match(CParser.Comma);
            this.state = 2512;
            _la = this._input.LA(1);
            if(_la===CParser.LeftBracket || _la===CParser.Dot) {
                this.state = 2511;
                this.designation();
            }

            this.state = 2514;
            this.initializer();
            this.state = 2515;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Designation_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_designation_DropletFile;
    return this;
}

Designation_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Designation_DropletFileContext.prototype.constructor = Designation_DropletFileContext;

Designation_DropletFileContext.prototype.designatorList = function() {
    return this.getTypedRuleContext(DesignatorListContext,0);
};

Designation_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Designation_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDesignation_DropletFile(this);
	}
};

Designation_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDesignation_DropletFile(this);
	}
};




CParser.Designation_DropletFileContext = Designation_DropletFileContext;

CParser.prototype.designation_DropletFile = function() {

    var localctx = new Designation_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 306, CParser.RULE_designation_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2519;
        this.designatorList(0);
        this.state = 2520;
        this.match(CParser.Assign);
        this.state = 2521;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DesignatorList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_designatorList_DropletFile;
    return this;
}

DesignatorList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DesignatorList_DropletFileContext.prototype.constructor = DesignatorList_DropletFileContext;

DesignatorList_DropletFileContext.prototype.designator = function() {
    return this.getTypedRuleContext(DesignatorContext,0);
};

DesignatorList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

DesignatorList_DropletFileContext.prototype.designatorList = function() {
    return this.getTypedRuleContext(DesignatorListContext,0);
};

DesignatorList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDesignatorList_DropletFile(this);
	}
};

DesignatorList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDesignatorList_DropletFile(this);
	}
};




CParser.DesignatorList_DropletFileContext = DesignatorList_DropletFileContext;

CParser.prototype.designatorList_DropletFile = function() {

    var localctx = new DesignatorList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 308, CParser.RULE_designatorList_DropletFile);
    try {
        this.state = 2530;
        var la_ = this._interp.adaptivePredict(this._input,243,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2523;
            this.designator();
            this.state = 2524;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2526;
            this.designatorList(0);
            this.state = 2527;
            this.designator();
            this.state = 2528;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Designator_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_designator_DropletFile;
    return this;
}

Designator_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Designator_DropletFileContext.prototype.constructor = Designator_DropletFileContext;

Designator_DropletFileContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

Designator_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Designator_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

Designator_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDesignator_DropletFile(this);
	}
};

Designator_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDesignator_DropletFile(this);
	}
};




CParser.Designator_DropletFileContext = Designator_DropletFileContext;

CParser.prototype.designator_DropletFile = function() {

    var localctx = new Designator_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 310, CParser.RULE_designator_DropletFile);
    try {
        this.state = 2540;
        switch(this._input.LA(1)) {
        case CParser.LeftBracket:
            this.enterOuterAlt(localctx, 1);
            this.state = 2532;
            this.match(CParser.LeftBracket);
            this.state = 2533;
            this.constantExpression();
            this.state = 2534;
            this.match(CParser.RightBracket);
            this.state = 2535;
            this.match(CParser.EOF);
            break;
        case CParser.Dot:
            this.enterOuterAlt(localctx, 2);
            this.state = 2537;
            this.match(CParser.Dot);
            this.state = 2538;
            this.match(CParser.Identifier);
            this.state = 2539;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function StaticAssertDeclaration_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_staticAssertDeclaration_DropletFile;
    return this;
}

StaticAssertDeclaration_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
StaticAssertDeclaration_DropletFileContext.prototype.constructor = StaticAssertDeclaration_DropletFileContext;

StaticAssertDeclaration_DropletFileContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

StaticAssertDeclaration_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

StaticAssertDeclaration_DropletFileContext.prototype.StringLiteral = function(i) {
	if(i===undefined) {
		i = null;
	}
    if(i===null) {
        return this.getTokens(CParser.StringLiteral);
    } else {
        return this.getToken(CParser.StringLiteral, i);
    }
};


StaticAssertDeclaration_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStaticAssertDeclaration_DropletFile(this);
	}
};

StaticAssertDeclaration_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStaticAssertDeclaration_DropletFile(this);
	}
};




CParser.StaticAssertDeclaration_DropletFileContext = StaticAssertDeclaration_DropletFileContext;

CParser.prototype.staticAssertDeclaration_DropletFile = function() {

    var localctx = new StaticAssertDeclaration_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 312, CParser.RULE_staticAssertDeclaration_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2542;
        this.match(CParser.StaticAssert);
        this.state = 2543;
        this.match(CParser.LeftParen);
        this.state = 2544;
        this.constantExpression();
        this.state = 2545;
        this.match(CParser.Comma);
        this.state = 2547; 
        this._errHandler.sync(this);
        _la = this._input.LA(1);
        do {
            this.state = 2546;
            this.match(CParser.StringLiteral);
            this.state = 2549; 
            this._errHandler.sync(this);
            _la = this._input.LA(1);
        } while(_la===CParser.StringLiteral);
        this.state = 2551;
        this.match(CParser.RightParen);
        this.state = 2552;
        this.match(CParser.Semi);
        this.state = 2553;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function Statement_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_statement_DropletFile;
    return this;
}

Statement_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
Statement_DropletFileContext.prototype.constructor = Statement_DropletFileContext;

Statement_DropletFileContext.prototype.labeledStatement = function() {
    return this.getTypedRuleContext(LabeledStatementContext,0);
};

Statement_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

Statement_DropletFileContext.prototype.compoundStatement = function() {
    return this.getTypedRuleContext(CompoundStatementContext,0);
};

Statement_DropletFileContext.prototype.expressionStatement = function() {
    return this.getTypedRuleContext(ExpressionStatementContext,0);
};

Statement_DropletFileContext.prototype.selectionStatement = function() {
    return this.getTypedRuleContext(SelectionStatementContext,0);
};

Statement_DropletFileContext.prototype.iterationStatement = function() {
    return this.getTypedRuleContext(IterationStatementContext,0);
};

Statement_DropletFileContext.prototype.jumpStatement = function() {
    return this.getTypedRuleContext(JumpStatementContext,0);
};

Statement_DropletFileContext.prototype.logicalOrExpression = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(LogicalOrExpressionContext);
    } else {
        return this.getTypedRuleContext(LogicalOrExpressionContext,i);
    }
};

Statement_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterStatement_DropletFile(this);
	}
};

Statement_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitStatement_DropletFile(this);
	}
};




CParser.Statement_DropletFileContext = Statement_DropletFileContext;

CParser.prototype.statement_DropletFile = function() {

    var localctx = new Statement_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 314, CParser.RULE_statement_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2605;
        var la_ = this._interp.adaptivePredict(this._input,251,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2555;
            this.labeledStatement();
            this.state = 2556;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2558;
            this.compoundStatement();
            this.state = 2559;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2561;
            this.expressionStatement();
            this.state = 2562;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 2564;
            this.selectionStatement();
            this.state = 2565;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 2567;
            this.iterationStatement();
            this.state = 2568;
            this.match(CParser.EOF);
            break;

        case 6:
            this.enterOuterAlt(localctx, 6);
            this.state = 2570;
            this.jumpStatement();
            this.state = 2571;
            this.match(CParser.EOF);
            break;

        case 7:
            this.enterOuterAlt(localctx, 7);
            this.state = 2573;
            _la = this._input.LA(1);
            if(!(_la===CParser.T__10 || _la===CParser.T__12)) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 2574;
            _la = this._input.LA(1);
            if(!(_la===CParser.T__13 || _la===CParser.Volatile)) {
            this._errHandler.recoverInline(this);
            }
            else {
                this.consume();
            }
            this.state = 2575;
            this.match(CParser.LeftParen);
            this.state = 2584;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2576;
                this.logicalOrExpression(0);
                this.state = 2581;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
                while(_la===CParser.Comma) {
                    this.state = 2577;
                    this.match(CParser.Comma);
                    this.state = 2578;
                    this.logicalOrExpression(0);
                    this.state = 2583;
                    this._errHandler.sync(this);
                    _la = this._input.LA(1);
                }
            }

            this.state = 2599;
            this._errHandler.sync(this);
            _la = this._input.LA(1);
            while(_la===CParser.Colon) {
                this.state = 2586;
                this.match(CParser.Colon);
                this.state = 2595;
                _la = this._input.LA(1);
                if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                    this.state = 2587;
                    this.logicalOrExpression(0);
                    this.state = 2592;
                    this._errHandler.sync(this);
                    _la = this._input.LA(1);
                    while(_la===CParser.Comma) {
                        this.state = 2588;
                        this.match(CParser.Comma);
                        this.state = 2589;
                        this.logicalOrExpression(0);
                        this.state = 2594;
                        this._errHandler.sync(this);
                        _la = this._input.LA(1);
                    }
                }

                this.state = 2601;
                this._errHandler.sync(this);
                _la = this._input.LA(1);
            }
            this.state = 2602;
            this.match(CParser.RightParen);
            this.state = 2603;
            this.match(CParser.Semi);
            this.state = 2604;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function LabeledStatement_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_labeledStatement_DropletFile;
    return this;
}

LabeledStatement_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
LabeledStatement_DropletFileContext.prototype.constructor = LabeledStatement_DropletFileContext;

LabeledStatement_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

LabeledStatement_DropletFileContext.prototype.statement = function() {
    return this.getTypedRuleContext(StatementContext,0);
};

LabeledStatement_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

LabeledStatement_DropletFileContext.prototype.constantExpression = function() {
    return this.getTypedRuleContext(ConstantExpressionContext,0);
};

LabeledStatement_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterLabeledStatement_DropletFile(this);
	}
};

LabeledStatement_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitLabeledStatement_DropletFile(this);
	}
};




CParser.LabeledStatement_DropletFileContext = LabeledStatement_DropletFileContext;

CParser.prototype.labeledStatement_DropletFile = function() {

    var localctx = new LabeledStatement_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 316, CParser.RULE_labeledStatement_DropletFile);
    try {
        this.state = 2623;
        switch(this._input.LA(1)) {
        case CParser.Identifier:
            this.enterOuterAlt(localctx, 1);
            this.state = 2607;
            this.match(CParser.Identifier);
            this.state = 2608;
            this.match(CParser.Colon);
            this.state = 2609;
            this.statement();
            this.state = 2610;
            this.match(CParser.EOF);
            break;
        case CParser.Case:
            this.enterOuterAlt(localctx, 2);
            this.state = 2612;
            this.match(CParser.Case);
            this.state = 2613;
            this.constantExpression();
            this.state = 2614;
            this.match(CParser.Colon);
            this.state = 2615;
            this.statement();
            this.state = 2616;
            this.match(CParser.EOF);
            break;
        case CParser.Default:
            this.enterOuterAlt(localctx, 3);
            this.state = 2618;
            this.match(CParser.Default);
            this.state = 2619;
            this.match(CParser.Colon);
            this.state = 2620;
            this.statement();
            this.state = 2621;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function CompoundStatement_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_compoundStatement_DropletFile;
    return this;
}

CompoundStatement_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
CompoundStatement_DropletFileContext.prototype.constructor = CompoundStatement_DropletFileContext;

CompoundStatement_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

CompoundStatement_DropletFileContext.prototype.blockItemList = function() {
    return this.getTypedRuleContext(BlockItemListContext,0);
};

CompoundStatement_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterCompoundStatement_DropletFile(this);
	}
};

CompoundStatement_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitCompoundStatement_DropletFile(this);
	}
};




CParser.CompoundStatement_DropletFileContext = CompoundStatement_DropletFileContext;

CParser.prototype.compoundStatement_DropletFile = function() {

    var localctx = new CompoundStatement_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 318, CParser.RULE_compoundStatement_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2625;
        this.match(CParser.LeftBrace);
        this.state = 2627;
        _la = this._input.LA(1);
        if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__10) | (1 << CParser.T__11) | (1 << CParser.T__12) | (1 << CParser.Auto) | (1 << CParser.Break) | (1 << CParser.Case) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Continue) | (1 << CParser.Default) | (1 << CParser.Do) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.For) | (1 << CParser.Goto) | (1 << CParser.If) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Return - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Sizeof - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Switch - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.While - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Alignof - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Generic - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)) | (1 << (CParser.LeftParen - 32)) | (1 << (CParser.LeftBrace - 32)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)) | (1 << (CParser.Semi - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
            this.state = 2626;
            this.blockItemList(0);
        }

        this.state = 2629;
        this.match(CParser.RightBrace);
        this.state = 2630;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function BlockItemList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_blockItemList_DropletFile;
    return this;
}

BlockItemList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
BlockItemList_DropletFileContext.prototype.constructor = BlockItemList_DropletFileContext;

BlockItemList_DropletFileContext.prototype.blockItem = function() {
    return this.getTypedRuleContext(BlockItemContext,0);
};

BlockItemList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

BlockItemList_DropletFileContext.prototype.blockItemList = function() {
    return this.getTypedRuleContext(BlockItemListContext,0);
};

BlockItemList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterBlockItemList_DropletFile(this);
	}
};

BlockItemList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitBlockItemList_DropletFile(this);
	}
};




CParser.BlockItemList_DropletFileContext = BlockItemList_DropletFileContext;

CParser.prototype.blockItemList_DropletFile = function() {

    var localctx = new BlockItemList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 320, CParser.RULE_blockItemList_DropletFile);
    try {
        this.state = 2639;
        var la_ = this._interp.adaptivePredict(this._input,254,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2632;
            this.blockItem();
            this.state = 2633;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2635;
            this.blockItemList(0);
            this.state = 2636;
            this.blockItem();
            this.state = 2637;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function BlockItem_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_blockItem_DropletFile;
    return this;
}

BlockItem_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
BlockItem_DropletFileContext.prototype.constructor = BlockItem_DropletFileContext;

BlockItem_DropletFileContext.prototype.specialMethodCall = function() {
    return this.getTypedRuleContext(SpecialMethodCallContext,0);
};

BlockItem_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

BlockItem_DropletFileContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

BlockItem_DropletFileContext.prototype.statement = function() {
    return this.getTypedRuleContext(StatementContext,0);
};

BlockItem_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterBlockItem_DropletFile(this);
	}
};

BlockItem_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitBlockItem_DropletFile(this);
	}
};




CParser.BlockItem_DropletFileContext = BlockItem_DropletFileContext;

CParser.prototype.blockItem_DropletFile = function() {

    var localctx = new BlockItem_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 322, CParser.RULE_blockItem_DropletFile);
    try {
        this.state = 2651;
        var la_ = this._interp.adaptivePredict(this._input,255,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2641;
            this.specialMethodCall();
            this.state = 2642;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2644;
            this.declaration();
            this.state = 2645;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2647;
            this.statement();
            this.state = 2648;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 2650;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function SpecialMethodCall_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_specialMethodCall_DropletFile;
    return this;
}

SpecialMethodCall_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
SpecialMethodCall_DropletFileContext.prototype.constructor = SpecialMethodCall_DropletFileContext;

SpecialMethodCall_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

SpecialMethodCall_DropletFileContext.prototype.assignmentExpression = function() {
    return this.getTypedRuleContext(AssignmentExpressionContext,0);
};

SpecialMethodCall_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

SpecialMethodCall_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterSpecialMethodCall_DropletFile(this);
	}
};

SpecialMethodCall_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitSpecialMethodCall_DropletFile(this);
	}
};




CParser.SpecialMethodCall_DropletFileContext = SpecialMethodCall_DropletFileContext;

CParser.prototype.specialMethodCall_DropletFile = function() {

    var localctx = new SpecialMethodCall_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 324, CParser.RULE_specialMethodCall_DropletFile);
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2653;
        this.match(CParser.Identifier);
        this.state = 2654;
        this.match(CParser.LeftParen);
        this.state = 2655;
        this.assignmentExpression();
        this.state = 2656;
        this.match(CParser.RightParen);
        this.state = 2657;
        this.match(CParser.Semi);
        this.state = 2658;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ExpressionStatement_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_expressionStatement_DropletFile;
    return this;
}

ExpressionStatement_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ExpressionStatement_DropletFileContext.prototype.constructor = ExpressionStatement_DropletFileContext;

ExpressionStatement_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ExpressionStatement_DropletFileContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

ExpressionStatement_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExpressionStatement_DropletFile(this);
	}
};

ExpressionStatement_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExpressionStatement_DropletFile(this);
	}
};




CParser.ExpressionStatement_DropletFileContext = ExpressionStatement_DropletFileContext;

CParser.prototype.expressionStatement_DropletFile = function() {

    var localctx = new ExpressionStatement_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 326, CParser.RULE_expressionStatement_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2661;
        _la = this._input.LA(1);
        if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
            this.state = 2660;
            this.expression(0);
        }

        this.state = 2663;
        this.match(CParser.Semi);
        this.state = 2664;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function SelectionStatement_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_selectionStatement_DropletFile;
    return this;
}

SelectionStatement_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
SelectionStatement_DropletFileContext.prototype.constructor = SelectionStatement_DropletFileContext;

SelectionStatement_DropletFileContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

SelectionStatement_DropletFileContext.prototype.statement = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(StatementContext);
    } else {
        return this.getTypedRuleContext(StatementContext,i);
    }
};

SelectionStatement_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

SelectionStatement_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterSelectionStatement_DropletFile(this);
	}
};

SelectionStatement_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitSelectionStatement_DropletFile(this);
	}
};




CParser.SelectionStatement_DropletFileContext = SelectionStatement_DropletFileContext;

CParser.prototype.selectionStatement_DropletFile = function() {

    var localctx = new SelectionStatement_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 328, CParser.RULE_selectionStatement_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2684;
        switch(this._input.LA(1)) {
        case CParser.If:
            this.enterOuterAlt(localctx, 1);
            this.state = 2666;
            this.match(CParser.If);
            this.state = 2667;
            this.match(CParser.LeftParen);
            this.state = 2668;
            this.expression(0);
            this.state = 2669;
            this.match(CParser.RightParen);
            this.state = 2670;
            this.statement();
            this.state = 2673;
            _la = this._input.LA(1);
            if(_la===CParser.Else) {
                this.state = 2671;
                this.match(CParser.Else);
                this.state = 2672;
                this.statement();
            }

            this.state = 2675;
            this.match(CParser.EOF);
            break;
        case CParser.Switch:
            this.enterOuterAlt(localctx, 2);
            this.state = 2677;
            this.match(CParser.Switch);
            this.state = 2678;
            this.match(CParser.LeftParen);
            this.state = 2679;
            this.expression(0);
            this.state = 2680;
            this.match(CParser.RightParen);
            this.state = 2681;
            this.statement();
            this.state = 2682;
            this.match(CParser.EOF);
            break;
        default:
            throw new antlr4.error.NoViableAltException(this);
        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function IterationStatement_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_iterationStatement_DropletFile;
    return this;
}

IterationStatement_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
IterationStatement_DropletFileContext.prototype.constructor = IterationStatement_DropletFileContext;

IterationStatement_DropletFileContext.prototype.expression = function(i) {
    if(i===undefined) {
        i = null;
    }
    if(i===null) {
        return this.getTypedRuleContexts(ExpressionContext);
    } else {
        return this.getTypedRuleContext(ExpressionContext,i);
    }
};

IterationStatement_DropletFileContext.prototype.statement = function() {
    return this.getTypedRuleContext(StatementContext,0);
};

IterationStatement_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

IterationStatement_DropletFileContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

IterationStatement_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterIterationStatement_DropletFile(this);
	}
};

IterationStatement_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitIterationStatement_DropletFile(this);
	}
};




CParser.IterationStatement_DropletFileContext = IterationStatement_DropletFileContext;

CParser.prototype.iterationStatement_DropletFile = function() {

    var localctx = new IterationStatement_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 330, CParser.RULE_iterationStatement_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2733;
        var la_ = this._interp.adaptivePredict(this._input,264,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2686;
            this.match(CParser.While);
            this.state = 2687;
            this.match(CParser.LeftParen);
            this.state = 2688;
            this.expression(0);
            this.state = 2689;
            this.match(CParser.RightParen);
            this.state = 2690;
            this.statement();
            this.state = 2691;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2693;
            this.match(CParser.Do);
            this.state = 2694;
            this.statement();
            this.state = 2695;
            this.match(CParser.While);
            this.state = 2696;
            this.match(CParser.LeftParen);
            this.state = 2697;
            this.expression(0);
            this.state = 2698;
            this.match(CParser.RightParen);
            this.state = 2699;
            this.match(CParser.Semi);
            this.state = 2700;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2702;
            this.match(CParser.For);
            this.state = 2703;
            this.match(CParser.LeftParen);
            this.state = 2705;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2704;
                this.expression(0);
            }

            this.state = 2707;
            this.match(CParser.Semi);
            this.state = 2709;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2708;
                this.expression(0);
            }

            this.state = 2711;
            this.match(CParser.Semi);
            this.state = 2713;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2712;
                this.expression(0);
            }

            this.state = 2715;
            this.match(CParser.RightParen);
            this.state = 2716;
            this.statement();
            this.state = 2717;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 2719;
            this.match(CParser.For);
            this.state = 2720;
            this.match(CParser.LeftParen);
            this.state = 2721;
            this.declaration();
            this.state = 2723;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2722;
                this.expression(0);
            }

            this.state = 2725;
            this.match(CParser.Semi);
            this.state = 2727;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2726;
                this.expression(0);
            }

            this.state = 2729;
            this.match(CParser.RightParen);
            this.state = 2730;
            this.statement();
            this.state = 2731;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function JumpStatement_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_jumpStatement_DropletFile;
    return this;
}

JumpStatement_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
JumpStatement_DropletFileContext.prototype.constructor = JumpStatement_DropletFileContext;

JumpStatement_DropletFileContext.prototype.Identifier = function() {
    return this.getToken(CParser.Identifier, 0);
};

JumpStatement_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

JumpStatement_DropletFileContext.prototype.expression = function() {
    return this.getTypedRuleContext(ExpressionContext,0);
};

JumpStatement_DropletFileContext.prototype.unaryExpression = function() {
    return this.getTypedRuleContext(UnaryExpressionContext,0);
};

JumpStatement_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterJumpStatement_DropletFile(this);
	}
};

JumpStatement_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitJumpStatement_DropletFile(this);
	}
};




CParser.JumpStatement_DropletFileContext = JumpStatement_DropletFileContext;

CParser.prototype.jumpStatement_DropletFile = function() {

    var localctx = new JumpStatement_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 332, CParser.RULE_jumpStatement_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2755;
        var la_ = this._interp.adaptivePredict(this._input,266,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2735;
            this.match(CParser.Goto);
            this.state = 2736;
            this.match(CParser.Identifier);
            this.state = 2737;
            this.match(CParser.Semi);
            this.state = 2738;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2739;
            this.match(CParser.Continue);
            this.state = 2740;
            this.match(CParser.Semi);
            this.state = 2741;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2742;
            this.match(CParser.Break);
            this.state = 2743;
            this.match(CParser.Semi);
            this.state = 2744;
            this.match(CParser.EOF);
            break;

        case 4:
            this.enterOuterAlt(localctx, 4);
            this.state = 2745;
            this.match(CParser.Return);
            this.state = 2747;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__1) | (1 << CParser.T__2))) !== 0) || ((((_la - 39)) & ~0x1f) == 0 && ((1 << (_la - 39)) & ((1 << (CParser.Sizeof - 39)) | (1 << (CParser.Alignof - 39)) | (1 << (CParser.Generic - 39)) | (1 << (CParser.LeftParen - 39)))) !== 0) || ((((_la - 71)) & ~0x1f) == 0 && ((1 << (_la - 71)) & ((1 << (CParser.Plus - 71)) | (1 << (CParser.PlusPlus - 71)) | (1 << (CParser.Minus - 71)) | (1 << (CParser.MinusMinus - 71)) | (1 << (CParser.Star - 71)) | (1 << (CParser.And - 71)) | (1 << (CParser.AndAnd - 71)) | (1 << (CParser.Not - 71)) | (1 << (CParser.Tilde - 71)))) !== 0) || ((((_la - 105)) & ~0x1f) == 0 && ((1 << (_la - 105)) & ((1 << (CParser.Identifier - 105)) | (1 << (CParser.Constant - 105)) | (1 << (CParser.StringLiteral - 105)))) !== 0)) {
                this.state = 2746;
                this.expression(0);
            }

            this.state = 2749;
            this.match(CParser.Semi);
            this.state = 2750;
            this.match(CParser.EOF);
            break;

        case 5:
            this.enterOuterAlt(localctx, 5);
            this.state = 2751;
            this.match(CParser.Goto);
            this.state = 2752;
            this.unaryExpression();
            this.state = 2753;
            this.match(CParser.Semi);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function CompilationUnit_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_compilationUnit_DropletFile;
    return this;
}

CompilationUnit_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
CompilationUnit_DropletFileContext.prototype.constructor = CompilationUnit_DropletFileContext;

CompilationUnit_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

CompilationUnit_DropletFileContext.prototype.translationUnit = function() {
    return this.getTypedRuleContext(TranslationUnitContext,0);
};

CompilationUnit_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterCompilationUnit_DropletFile(this);
	}
};

CompilationUnit_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitCompilationUnit_DropletFile(this);
	}
};




CParser.CompilationUnit_DropletFileContext = CompilationUnit_DropletFileContext;

CParser.prototype.compilationUnit_DropletFile = function() {

    var localctx = new CompilationUnit_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 334, CParser.RULE_compilationUnit_DropletFile);
    var _la = 0; // Token type
    try {
        this.state = 2762;
        var la_ = this._interp.adaptivePredict(this._input,268,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2758;
            _la = this._input.LA(1);
            if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)) | (1 << (CParser.LeftParen - 32)))) !== 0) || ((((_la - 75)) & ~0x1f) == 0 && ((1 << (_la - 75)) & ((1 << (CParser.Star - 75)) | (1 << (CParser.Caret - 75)) | (1 << (CParser.Semi - 75)) | (1 << (CParser.Identifier - 75)))) !== 0)) {
                this.state = 2757;
                this.translationUnit(0);
            }

            this.state = 2760;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2761;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function TranslationUnit_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_translationUnit_DropletFile;
    return this;
}

TranslationUnit_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
TranslationUnit_DropletFileContext.prototype.constructor = TranslationUnit_DropletFileContext;

TranslationUnit_DropletFileContext.prototype.externalDeclaration = function() {
    return this.getTypedRuleContext(ExternalDeclarationContext,0);
};

TranslationUnit_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

TranslationUnit_DropletFileContext.prototype.translationUnit = function() {
    return this.getTypedRuleContext(TranslationUnitContext,0);
};

TranslationUnit_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterTranslationUnit_DropletFile(this);
	}
};

TranslationUnit_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitTranslationUnit_DropletFile(this);
	}
};




CParser.TranslationUnit_DropletFileContext = TranslationUnit_DropletFileContext;

CParser.prototype.translationUnit_DropletFile = function() {

    var localctx = new TranslationUnit_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 336, CParser.RULE_translationUnit_DropletFile);
    try {
        this.state = 2771;
        var la_ = this._interp.adaptivePredict(this._input,269,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2764;
            this.externalDeclaration();
            this.state = 2765;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2767;
            this.translationUnit(0);
            this.state = 2768;
            this.externalDeclaration();
            this.state = 2769;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function ExternalDeclaration_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_externalDeclaration_DropletFile;
    return this;
}

ExternalDeclaration_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
ExternalDeclaration_DropletFileContext.prototype.constructor = ExternalDeclaration_DropletFileContext;

ExternalDeclaration_DropletFileContext.prototype.functionDefinition = function() {
    return this.getTypedRuleContext(FunctionDefinitionContext,0);
};

ExternalDeclaration_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

ExternalDeclaration_DropletFileContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

ExternalDeclaration_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterExternalDeclaration_DropletFile(this);
	}
};

ExternalDeclaration_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitExternalDeclaration_DropletFile(this);
	}
};




CParser.ExternalDeclaration_DropletFileContext = ExternalDeclaration_DropletFileContext;

CParser.prototype.externalDeclaration_DropletFile = function() {

    var localctx = new ExternalDeclaration_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 338, CParser.RULE_externalDeclaration_DropletFile);
    try {
        this.state = 2780;
        var la_ = this._interp.adaptivePredict(this._input,270,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2773;
            this.functionDefinition();
            this.state = 2774;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2776;
            this.declaration();
            this.state = 2777;
            this.match(CParser.EOF);
            break;

        case 3:
            this.enterOuterAlt(localctx, 3);
            this.state = 2779;
            this.match(CParser.Semi);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function FunctionDefinition_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_functionDefinition_DropletFile;
    return this;
}

FunctionDefinition_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
FunctionDefinition_DropletFileContext.prototype.constructor = FunctionDefinition_DropletFileContext;

FunctionDefinition_DropletFileContext.prototype.declarator = function() {
    return this.getTypedRuleContext(DeclaratorContext,0);
};

FunctionDefinition_DropletFileContext.prototype.compoundStatement = function() {
    return this.getTypedRuleContext(CompoundStatementContext,0);
};

FunctionDefinition_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

FunctionDefinition_DropletFileContext.prototype.declarationSpecifiers = function() {
    return this.getTypedRuleContext(DeclarationSpecifiersContext,0);
};

FunctionDefinition_DropletFileContext.prototype.declarationList = function() {
    return this.getTypedRuleContext(DeclarationListContext,0);
};

FunctionDefinition_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterFunctionDefinition_DropletFile(this);
	}
};

FunctionDefinition_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitFunctionDefinition_DropletFile(this);
	}
};




CParser.FunctionDefinition_DropletFileContext = FunctionDefinition_DropletFileContext;

CParser.prototype.functionDefinition_DropletFile = function() {

    var localctx = new FunctionDefinition_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 340, CParser.RULE_functionDefinition_DropletFile);
    var _la = 0; // Token type
    try {
        this.enterOuterAlt(localctx, 1);
        this.state = 2783;
        var la_ = this._interp.adaptivePredict(this._input,271,this._ctx);
        if(la_===1) {
            this.state = 2782;
            this.declarationSpecifiers();

        }
        this.state = 2785;
        this.declarator();
        this.state = 2787;
        _la = this._input.LA(1);
        if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << CParser.T__0) | (1 << CParser.T__3) | (1 << CParser.T__4) | (1 << CParser.T__5) | (1 << CParser.T__6) | (1 << CParser.T__7) | (1 << CParser.T__8) | (1 << CParser.T__9) | (1 << CParser.T__11) | (1 << CParser.Auto) | (1 << CParser.Char) | (1 << CParser.Const) | (1 << CParser.Double) | (1 << CParser.Enum) | (1 << CParser.Extern) | (1 << CParser.Float) | (1 << CParser.Inline))) !== 0) || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (CParser.Int - 32)) | (1 << (CParser.Long - 32)) | (1 << (CParser.Register - 32)) | (1 << (CParser.Restrict - 32)) | (1 << (CParser.Short - 32)) | (1 << (CParser.Signed - 32)) | (1 << (CParser.Static - 32)) | (1 << (CParser.Struct - 32)) | (1 << (CParser.Typedef - 32)) | (1 << (CParser.Union - 32)) | (1 << (CParser.Unsigned - 32)) | (1 << (CParser.Void - 32)) | (1 << (CParser.Volatile - 32)) | (1 << (CParser.Alignas - 32)) | (1 << (CParser.Atomic - 32)) | (1 << (CParser.Bool - 32)) | (1 << (CParser.Complex - 32)) | (1 << (CParser.Noreturn - 32)) | (1 << (CParser.StaticAssert - 32)) | (1 << (CParser.ThreadLocal - 32)))) !== 0) || _la===CParser.Identifier) {
            this.state = 2786;
            this.declarationList(0);
        }

        this.state = 2789;
        this.compoundStatement();
        this.state = 2790;
        this.match(CParser.EOF);
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};

function DeclarationList_DropletFileContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;
	}
	if(invokingState===undefined || invokingState===null) {
		invokingState = -1;
	}
	antlr4.ParserRuleContext.call(this, parent, invokingState);
    this.parser = parser;
    this.ruleIndex = CParser.RULE_declarationList_DropletFile;
    return this;
}

DeclarationList_DropletFileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype);
DeclarationList_DropletFileContext.prototype.constructor = DeclarationList_DropletFileContext;

DeclarationList_DropletFileContext.prototype.declaration = function() {
    return this.getTypedRuleContext(DeclarationContext,0);
};

DeclarationList_DropletFileContext.prototype.EOF = function() {
    return this.getToken(CParser.EOF, 0);
};

DeclarationList_DropletFileContext.prototype.declarationList = function() {
    return this.getTypedRuleContext(DeclarationListContext,0);
};

DeclarationList_DropletFileContext.prototype.enterRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.enterDeclarationList_DropletFile(this);
	}
};

DeclarationList_DropletFileContext.prototype.exitRule = function(listener) {
    if(listener instanceof CListener ) {
        listener.exitDeclarationList_DropletFile(this);
	}
};




CParser.DeclarationList_DropletFileContext = DeclarationList_DropletFileContext;

CParser.prototype.declarationList_DropletFile = function() {

    var localctx = new DeclarationList_DropletFileContext(this, this._ctx, this.state);
    this.enterRule(localctx, 342, CParser.RULE_declarationList_DropletFile);
    try {
        this.state = 2799;
        var la_ = this._interp.adaptivePredict(this._input,273,this._ctx);
        switch(la_) {
        case 1:
            this.enterOuterAlt(localctx, 1);
            this.state = 2792;
            this.declaration();
            this.state = 2793;
            this.match(CParser.EOF);
            break;

        case 2:
            this.enterOuterAlt(localctx, 2);
            this.state = 2795;
            this.declarationList(0);
            this.state = 2796;
            this.declaration();
            this.state = 2797;
            this.match(CParser.EOF);
            break;

        }
    } catch (re) {
    	if(re instanceof antlr4.error.RecognitionException) {
	        localctx.exception = re;
	        this._errHandler.reportError(this, re);
	        this._errHandler.recover(this, re);
	    } else {
	    	throw re;
	    }
    } finally {
        this.exitRule();
    }
    return localctx;
};


CParser.prototype.sempred = function(localctx, ruleIndex, predIndex) {
	switch(ruleIndex) {
	case 2:
			return this.genericAssocList_sempred(localctx, predIndex);
	case 4:
			return this.postfixExpression_sempred(localctx, predIndex);
	case 5:
			return this.argumentExpressionList_sempred(localctx, predIndex);
	case 9:
			return this.multiplicativeExpression_sempred(localctx, predIndex);
	case 10:
			return this.additiveExpression_sempred(localctx, predIndex);
	case 11:
			return this.shiftExpression_sempred(localctx, predIndex);
	case 12:
			return this.relationalExpression_sempred(localctx, predIndex);
	case 13:
			return this.equalityExpression_sempred(localctx, predIndex);
	case 14:
			return this.andExpression_sempred(localctx, predIndex);
	case 15:
			return this.exclusiveOrExpression_sempred(localctx, predIndex);
	case 16:
			return this.inclusiveOrExpression_sempred(localctx, predIndex);
	case 17:
			return this.logicalAndExpression_sempred(localctx, predIndex);
	case 18:
			return this.logicalOrExpression_sempred(localctx, predIndex);
	case 22:
			return this.expression_sempred(localctx, predIndex);
	case 28:
			return this.initDeclaratorList_sempred(localctx, predIndex);
	case 35:
			return this.structDeclarationList_sempred(localctx, predIndex);
	case 38:
			return this.structDeclaratorList_sempred(localctx, predIndex);
	case 41:
			return this.enumeratorList_sempred(localctx, predIndex);
	case 49:
			return this.directDeclarator_sempred(localctx, predIndex);
	case 56:
			return this.typeQualifierList_sempred(localctx, predIndex);
	case 58:
			return this.parameterList_sempred(localctx, predIndex);
	case 60:
			return this.identifierList_sempred(localctx, predIndex);
	case 63:
			return this.directAbstractDeclarator_sempred(localctx, predIndex);
	case 66:
			return this.initializerList_sempred(localctx, predIndex);
	case 68:
			return this.designatorList_sempred(localctx, predIndex);
	case 74:
			return this.blockItemList_sempred(localctx, predIndex);
	case 82:
			return this.translationUnit_sempred(localctx, predIndex);
	case 85:
			return this.declarationList_sempred(localctx, predIndex);
    default:
        throw "No predicate with index:" + ruleIndex;
   }
};

CParser.prototype.genericAssocList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 0:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.postfixExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 1:
			return this.precpred(this._ctx, 10);
		case 2:
			return this.precpred(this._ctx, 9);
		case 3:
			return this.precpred(this._ctx, 8);
		case 4:
			return this.precpred(this._ctx, 7);
		case 5:
			return this.precpred(this._ctx, 6);
		case 6:
			return this.precpred(this._ctx, 5);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.argumentExpressionList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 7:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.multiplicativeExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 8:
			return this.precpred(this._ctx, 3);
		case 9:
			return this.precpred(this._ctx, 2);
		case 10:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.additiveExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 11:
			return this.precpred(this._ctx, 2);
		case 12:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.shiftExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 13:
			return this.precpred(this._ctx, 2);
		case 14:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.relationalExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 15:
			return this.precpred(this._ctx, 4);
		case 16:
			return this.precpred(this._ctx, 3);
		case 17:
			return this.precpred(this._ctx, 2);
		case 18:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.equalityExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 19:
			return this.precpred(this._ctx, 2);
		case 20:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.andExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 21:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.exclusiveOrExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 22:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.inclusiveOrExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 23:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.logicalAndExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 24:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.logicalOrExpression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 25:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.expression_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 26:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.initDeclaratorList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 27:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.structDeclarationList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 28:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.structDeclaratorList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 29:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.enumeratorList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 30:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.directDeclarator_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 31:
			return this.precpred(this._ctx, 6);
		case 32:
			return this.precpred(this._ctx, 5);
		case 33:
			return this.precpred(this._ctx, 4);
		case 34:
			return this.precpred(this._ctx, 3);
		case 35:
			return this.precpred(this._ctx, 2);
		case 36:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.typeQualifierList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 37:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.parameterList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 38:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.identifierList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 39:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.directAbstractDeclarator_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 40:
			return this.precpred(this._ctx, 5);
		case 41:
			return this.precpred(this._ctx, 4);
		case 42:
			return this.precpred(this._ctx, 3);
		case 43:
			return this.precpred(this._ctx, 2);
		case 44:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.initializerList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 45:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.designatorList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 46:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.blockItemList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 47:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.translationUnit_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 48:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};

CParser.prototype.declarationList_sempred = function(localctx, predIndex) {
	switch(predIndex) {
		case 49:
			return this.precpred(this._ctx, 1);
		default:
			throw "No predicate with index:" + predIndex;
	}
};


exports.CParser = CParser;
